From cfdca08cfe002d7f03006e2337f7747b0103e628 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Fri, 6 Jan 2023 11:52:30 -0500 Subject: [PATCH] CME Template 8 --- src/lib/config/protos/jetfix.proto | 2 +- src/lib/orderman/CreateOrderMsg.h | 22 + src/lib/orderman/ilink3/IL3GW.cpp | 61 +- src/lib/orderman/ilink3/IL3MessageFramer.h | 5 +- src/lib/orderman/ilink3/ILink3Utils.cpp | 4 +- src/lib/orderman/ilink3/SessionStore.cpp | 3 + src/lib/orderman/ilink3/generated/AvgPxInd.h | 153 +- .../orderman/ilink3/generated/BooleanFlag.h | 144 +- .../orderman/ilink3/generated/BooleanNULL.h | 144 +- .../ilink3/generated/BusinessReject521.h | 2974 +++-- .../ilink3/generated/ClearingAcctType.h | 146 +- .../orderman/ilink3/generated/CmtaGiveUpCD.h | 140 +- .../ilink3/generated/CustOrdHandlInst.h | 178 +- .../ilink3/generated/CustOrderCapacity.h | 162 +- src/lib/orderman/ilink3/generated/DATA.h | 422 +- src/lib/orderman/ilink3/generated/DKReason.h | 192 +- .../orderman/ilink3/generated/Decimal32NULL.h | 454 +- .../orderman/ilink3/generated/Decimal64NULL.h | 464 +- .../orderman/ilink3/generated/Establish503.h | 3813 +++--- .../ilink3/generated/EstablishmentAck504.h | 1471 ++- .../ilink3/generated/EstablishmentReject505.h | 1455 ++- .../orderman/ilink3/generated/ExecAckStatus.h | 144 +- src/lib/orderman/ilink3/generated/ExecInst.h | 754 +- src/lib/orderman/ilink3/generated/ExecMode.h | 144 +- .../orderman/ilink3/generated/ExecReason.h | 210 +- .../orderman/ilink3/generated/ExecTypTrdCxl.h | 144 +- .../ilink3/generated/ExecutionAck539.h | 2762 ++-- .../generated/ExecutionReportCancel534.h | 6018 +++++---- .../generated/ExecutionReportElimination524.h | 5152 ++++---- .../generated/ExecutionReportModify531.h | 5498 ++++---- .../ilink3/generated/ExecutionReportNew522.h | 5339 ++++---- .../ExecutionReportPendingCancel564.h | 3803 ++++++ .../ExecutionReportPendingReplace565.h | 3340 +++++ .../generated/ExecutionReportReject523.h | 5690 ++++---- .../generated/ExecutionReportStatus532.h | 6242 +++++---- .../ExecutionReportTradeAddendumOutright548.h | 8722 +++++++------ .../ExecutionReportTradeAddendumSpread549.h | 10063 +++++++------- ...ExecutionReportTradeAddendumSpreadLeg550.h | 7665 ++++++----- .../ExecutionReportTradeOutright525.h | 10592 ++++++++------- .../generated/ExecutionReportTradeSpread526.h | 10805 ++++++++-------- .../ExecutionReportTradeSpreadLeg527.h | 7833 +++++------ src/lib/orderman/ilink3/generated/ExpCycle.h | 144 +- src/lib/orderman/ilink3/generated/FTI.h | 144 +- src/lib/orderman/ilink3/generated/GroupSize.h | 456 +- .../ilink3/generated/KeepAliveLapsed.h | 145 +- .../orderman/ilink3/generated/ListUpdAct.h | 140 +- .../orderman/ilink3/generated/ManualOrdInd.h | 144 +- .../ilink3/generated/ManualOrdIndReq.h | 145 +- .../ilink3/generated/MassActionOrdTyp.h | 142 +- .../ilink3/generated/MassActionResponse.h | 146 +- .../ilink3/generated/MassActionScope.h | 169 +- .../orderman/ilink3/generated/MassCancelTIF.h | 152 +- .../orderman/ilink3/generated/MassCxlReqTyp.h | 144 +- .../orderman/ilink3/generated/MassQuote517.h | 4922 +++---- .../ilink3/generated/MassQuoteAck545.h | 4608 ++++--- .../ilink3/generated/MassStatusOrdTyp.h | 146 +- .../ilink3/generated/MassStatusReqTyp.h | 157 +- .../orderman/ilink3/generated/MassStatusTIF.h | 155 +- .../ilink3/generated/MaturityMonthYear.h | 657 +- .../orderman/ilink3/generated/MessageHeader.h | 658 +- .../orderman/ilink3/generated/Negotiate500.h | 2786 ++-- .../ilink3/generated/NegotiationReject502.h | 1349 +- .../ilink3/generated/NegotiationResponse501.h | 1792 +-- .../ilink3/generated/NewOrderCross544.h | 3970 +++--- .../ilink3/generated/NewOrderSingle514.h | 3528 ++--- .../orderman/ilink3/generated/NotApplied513.h | 939 +- .../ilink3/generated/OFMOverrideReq.h | 144 +- .../orderman/ilink3/generated/OrdStatusTrd.h | 144 +- .../ilink3/generated/OrdStatusTrdCxl.h | 145 +- .../ilink3/generated/OrderCancelReject535.h | 3954 +++--- .../generated/OrderCancelReplaceReject536.h | 3967 +++--- .../generated/OrderCancelReplaceRequest515.h | 3687 +++--- .../ilink3/generated/OrderCancelRequest516.h | 2657 ++-- .../ilink3/generated/OrderEventType.h | 144 +- .../generated/OrderMassActionReport558.h | 3202 ----- .../generated/OrderMassActionReport562.h | 5658 ++++---- .../generated/OrderMassActionRequest529.h | 3246 +++-- .../generated/OrderMassStatusRequest530.h | 2540 ++-- .../orderman/ilink3/generated/OrderStatus.h | 198 +- .../ilink3/generated/OrderStatusRequest533.h | 1813 +-- src/lib/orderman/ilink3/generated/OrderType.h | 160 +- .../orderman/ilink3/generated/OrderTypeReq.h | 168 +- src/lib/orderman/ilink3/generated/PRICE9.h | 433 +- .../orderman/ilink3/generated/PRICENULL9.h | 433 +- .../ilink3/generated/PartyDetailRole.h | 169 +- .../PartyDetailsDefinitionRequest518.h | 4683 +++---- .../PartyDetailsDefinitionRequestAck519.h | 5210 ++++---- .../generated/PartyDetailsListReport538.h | 4890 +++---- .../generated/PartyDetailsListRequest537.h | 2784 ++-- .../ilink3/generated/QuoteAckStatus.h | 144 +- .../ilink3/generated/QuoteCancel528.h | 4034 +++--- .../ilink3/generated/QuoteCancelAck547.h | 3051 ----- .../ilink3/generated/QuoteCancelAck563.h | 5881 +++++---- .../ilink3/generated/QuoteCxlStatus.h | 168 +- .../orderman/ilink3/generated/QuoteCxlTyp.h | 160 +- src/lib/orderman/ilink3/generated/QuoteTyp.h | 133 +- src/lib/orderman/ilink3/generated/README.txt | 24 +- src/lib/orderman/ilink3/generated/RFQSide.h | 152 +- src/lib/orderman/ilink3/generated/ReqResult.h | 160 +- .../ilink3/generated/RequestForQuote543.h | 2682 ++-- .../ilink3/generated/RequestForQuoteAck546.h | 3187 ++--- .../ilink3/generated/Retransmission509.h | 1152 +- .../ilink3/generated/RetransmitReject510.h | 1361 +- .../ilink3/generated/RetransmitRequest508.h | 1063 +- src/lib/orderman/ilink3/generated/SLEDS.h | 144 +- src/lib/orderman/ilink3/generated/SMPI.h | 144 +- src/lib/orderman/ilink3/generated/SecRspTyp.h | 153 +- .../generated/SecurityDefinitionRequest560.h | 4948 +++---- .../generated/SecurityDefinitionResponse561.h | 9167 +++++++------ .../orderman/ilink3/generated/Sequence506.h | 930 +- .../orderman/ilink3/generated/ShortSaleType.h | 160 +- src/lib/orderman/ilink3/generated/SideNULL.h | 144 +- src/lib/orderman/ilink3/generated/SideReq.h | 147 +- .../ilink3/generated/SideTimeInForce.h | 145 +- src/lib/orderman/ilink3/generated/SplitMsg.h | 152 +- .../orderman/ilink3/generated/Terminate507.h | 1253 +- .../orderman/ilink3/generated/TimeInForce.h | 171 +- .../orderman/ilink3/generated/TradeAddendum.h | 160 +- src/lib/orderman/ilink3/generated/generate.sh | 3 +- .../orderman/ilink3/generated/ilinkbinary.xml | 289 +- .../ilink3/generated/sbe-all-1.17.0.jar | Bin 709290 -> 0 bytes .../ilink3/generated/sbe-all-1.27.0.jar | Bin 0 -> 856691 bytes .../orderman/order_factory/OrderFactory.cpp | 14 +- src/lib/utils/AuthSessionManager.cpp | 42 +- src/server/sparkd/cmds/CMECert.cpp | 2 + 125 files changed, 124104 insertions(+), 108912 deletions(-) create mode 100644 src/lib/orderman/ilink3/generated/ExecutionReportPendingCancel564.h create mode 100644 src/lib/orderman/ilink3/generated/ExecutionReportPendingReplace565.h delete mode 100644 src/lib/orderman/ilink3/generated/OrderMassActionReport558.h delete mode 100644 src/lib/orderman/ilink3/generated/QuoteCancelAck547.h mode change 100755 => 100644 src/lib/orderman/ilink3/generated/generate.sh delete mode 100755 src/lib/orderman/ilink3/generated/sbe-all-1.17.0.jar create mode 100644 src/lib/orderman/ilink3/generated/sbe-all-1.27.0.jar diff --git a/src/lib/config/protos/jetfix.proto b/src/lib/config/protos/jetfix.proto index 8e427c91a..0c6077513 100644 --- a/src/lib/config/protos/jetfix.proto +++ b/src/lib/config/protos/jetfix.proto @@ -89,7 +89,7 @@ message JetFIX { optional uint32 window_duration_msecs = 345 [ default = 1000 ]; // leave it alone - optional uint32 max_connection_attempts = 346 [ default = 10 ]; + optional uint32 max_connection_attempts = 346 [ default = 3 ]; optional bool auto_fix_seq_num = 347 [ default = false ]; optional bool use_ilink3 = 348 [ default = false ]; } diff --git a/src/lib/orderman/CreateOrderMsg.h b/src/lib/orderman/CreateOrderMsg.h index 90f05d315..bdd05e5ee 100644 --- a/src/lib/orderman/CreateOrderMsg.h +++ b/src/lib/orderman/CreateOrderMsg.h @@ -1,5 +1,8 @@ #pragma once +#include "lib/domain_model/Security.h" +#include "lib/domain_model/common.h" #include "lib/orderman/orderman_utils/orderman_common.h" +#include "lib/utils/PBUtils.h" namespace bts::orderman { @@ -17,4 +20,23 @@ struct CreateOrderMsg { api::orderman::RoutingRecord const *routing_record; }; +inline std::ostream &operator<<(std::ostream &out, CreateOrderMsg const &msg) { + out << "key: " << msg.key.value() << " price: " << msg.price.value() + << " qty: " << msg.quantity.full_value() << " security: " + << (msg.security == nullptr ? "NULL" + : utils::pb::to_string(*msg.security)) + << " side: " << securities::side_name(msg.side) + << " display_qty: " << msg.display_quantity.full_value() + << " order_type: " << api::orderman::NativeOrderType_Name(msg.order_type) + << " time_in_force: " + << api::orderman::TimeInForce_Name(msg.time_in_force) + << " manual_order_indicator: " + << api::orderman::ManualOrderIndicator_Name(msg.manual_order_indicator) + << " routing_record: " + << (msg.routing_record == nullptr + ? "NULL" + : utils::pb::to_string(*msg.routing_record)); + return out; +} + } // namespace bts::orderman diff --git a/src/lib/orderman/ilink3/IL3GW.cpp b/src/lib/orderman/ilink3/IL3GW.cpp index ceb0b8189..a8f28da10 100644 --- a/src/lib/orderman/ilink3/IL3GW.cpp +++ b/src/lib/orderman/ilink3/IL3GW.cpp @@ -3,6 +3,8 @@ #include "IL3GeneratedFull.h" #include "IL3MessageFramer.h" #include "ILink3Utils.h" +#include "lib/logging/logging.h" +#include "lib/orderman/ilink3/generated/PartyDetailsDefinitionRequest518.h" #include "lib/orderman/orderman_utils/fix_order_codec.h" #include "lib/utils/SecureLogon.h" #include "lib/utils/bts_assert.h" @@ -46,10 +48,16 @@ IL3GW::IL3GW( _on_state_change([](auto) {}), _on_exe_report([](auto *) {}), _on_session_change([](auto) {}), _connection(con), _session(session), _msg_count(0), _time(), _pool(), _exe_parser(cfg, db), _retransmit() { + LOG(OrderMan, Info, + "IL3GW::IL3GW cme_session: {} uuid: {} to_cme: {} from_cme: {}", + _config.cme_session, _session.uuid, _session.to_cme, _session.from_cme); _clorid_buffer.resize(clordid_sz()); } void IL3GW::connect() { + LOG(OrderMan, Info, + "IL3GW::connect cme_session: {} uuid: {} to_cme: {} from_cme: {}", + _config.cme_session, _session.uuid, _session.to_cme, _session.from_cme); bts_assert(state() == State::INIT || state() == State::ERROR); set_state(State::CONNECTING); _connection.connect(*this); // -> on_connect_success @@ -57,6 +65,9 @@ void IL3GW::connect() { // This determines the session uuid void IL3GW::send_negotiate() { + LOG(OrderMan, Info, + "IL3GW::send_negotiate cme_session: {} uuid: {} to_cme: {} from_cme: {}", + _config.cme_session, _session.uuid, _session.to_cme, _session.from_cme); // add 2 bytes for the empty 'credentials' (39008) length which must be // present auto msg = _buffer.frame( @@ -89,6 +100,9 @@ void IL3GW::send_negotiate() { } void IL3GW::send_establish() { + LOG(OrderMan, Info, + "IL3GW::send_establish cme_session: {} uuid: {} to_cme: {} from_cme: {}", + _config.cme_session, _session.uuid, _session.to_cme, _session.from_cme); // add 2 bytes for the empty 'credentials' (39008) length which must be // present auto msg = _buffer.frame(2); @@ -158,6 +172,9 @@ void IL3GW::send_retransmit_request( log_out(msg, 0); } +// This is called on new order, cxl-replace and cxl +// https://www.cmegroup.com/confluence/display/EPICSANDBOX/iLink+3+Party+Details+Definition+Request + uint64_t IL3GW::send_party_details(const api::orderman::RoutingRecord &route) { using namespace iLinkBinary; @@ -183,9 +200,11 @@ uint64_t IL3GW::send_party_details(const api::orderman::RoutingRecord &route) { auto smp_id = std::atoi(route.smp_id().c_str()); msg.selfMatchPreventionID(smp_id); } + // Tag 9708 msg.cmtaGiveupCD(CmtaGiveUpCD::NULL_VALUE); msg.custOrderCapacity(map_cust_cti(route.cti_code())); msg.clearingAccountType(map_customer_or_firm(route.customer_or_firm())); + // Tag 8000 msg.selfMatchPreventionInstruction( map_smp_instruction(route.smp_instruction())); msg.avgPxIndicator(AvgPxInd::NULL_VALUE); @@ -228,6 +247,8 @@ bool need_px(api::orderman::NativeOrderType order_type) { order_type != api::orderman::NativeOrderType::NATIVE_ORDER_TYPE_STOP; } +// All new orders go through here. +// https://www.cmegroup.com/confluence/display/EPICSANDBOX/iLink+3+Execution+Report+-+New+Order void IL3GW::send_order( const CreateOrderMsg &create, trace::CorID const &corid) { _current_corid = corid; @@ -258,7 +279,29 @@ void IL3GW::send_order( encode_clorid( create.key, SecurityKey(create.security->id()), &_clorid_buffer); msg.putClOrdID(_clorid_buffer); - msg.partyDetailsListReqID(party); + // From the link above: + // (we do not "pre-register", which would have been better, but send + // "on-demand messages". + + // The unique identifier of the Party Details Definition + // Request Acknowledgment associated with this message; this is the value + // submitted on the inbound message. + + // For pre-registered messages: + + // - Unique ID from Party Details Definition Request Acknowledgment message + // - PartyDetailsListRequestID≠0. + + // For on-demand messages: + + // - If not registered beforehand through iLink then Party Details Definition + // Request message will be sent along with the business message and will + // immediately precede it + // - PartyDetailsListRequestID=0. + msg.partyDetailsListReqID(party); // party=0 (check send_party_details) + // an incorrect party id results in: + // Business Reject: 1 'Unknown ID (unknown PartyDetailsListReqID being + // referenced in business message)'. msg.orderRequestID(++_msg_count); msg.sendingTimeEpoch(_time.now()); if (needs_stop_px(create.order_type)) { @@ -288,7 +331,11 @@ void IL3GW::send_order( msg.liquidityFlag(iLinkBinary::BooleanNULL::NULL_VALUE); msg.managedOrder(iLinkBinary::BooleanNULL::NULL_VALUE); msg.shortSaleType(iLinkBinary::ShortSaleType::NULL_VALUE); + // this writes it to the log file + // ~/sparkdata/data/ilink3///log log_out(msg, msg.seqNum()); + // the message is written to the buffer not not sent yet, that happens when + // flush is called (check GLBXiLink3ExecutionGateway::send_msgs) } void IL3GW::send_cancel_replace( @@ -371,7 +418,11 @@ void IL3GW::send_cancel( } void IL3GW::send_terminate(uint16_t code) { - LOG(iLink3, Info, "Terminate"); + LOG(OrderMan, Info, + "IL3GW::send_terminate cme_session: {} uuid: {} to_cme: {} " + "from_cme: {} code: {}", + _config.cme_session, _session.uuid, _session.to_cme, _session.from_cme, + code); auto msg = _buffer.frame(); msg.uUID(_session.uuid); msg.requestTimestamp(_time.now()); @@ -421,9 +472,13 @@ void IL3GW::set_state(State s) { // IConnectionHandler void IL3GW::on_connect_success() { + LOG(OrderMan, Info, + "IL3GW::on_connect_success cme_session: {} uuid: {} to_cme: {} " + "from_cme: {}", + _config.cme_session, _session.uuid, _session.to_cme, _session.from_cme); if (!_session) { // If we have a 0 cme_seq this is a new session and we need to negotiate - // it + // it (this is the only time a negotiation is sent) LOG(iLink3, Info, "Negotiating new iLink session. {}", _session.uuid); set_state(State::NEGOTIATING); send_negotiate(); diff --git a/src/lib/orderman/ilink3/IL3MessageFramer.h b/src/lib/orderman/ilink3/IL3MessageFramer.h index c5747c3c2..4e62ae94b 100644 --- a/src/lib/orderman/ilink3/IL3MessageFramer.h +++ b/src/lib/orderman/ilink3/IL3MessageFramer.h @@ -35,7 +35,10 @@ class IL3MessageFramer { // structure until flush() is called, at which point the currently // accumulatd buffers are forwarded to the IL3Connection and // accumulation restarts. - template Msg frame(size_t extra = 0) { + template + Msg frame(size_t extra = 0) { + // this is how the header is organized + // https://www.cmegroup.com/confluence/display/EPICSANDBOX/iLink+3+Message+Header auto size = sizeof(FramingHeader) + iLinkBinary::MessageHeader::encodedLength() + Msg::sbeBlockLength() + extra; diff --git a/src/lib/orderman/ilink3/ILink3Utils.cpp b/src/lib/orderman/ilink3/ILink3Utils.cpp index 9bba8d3dd..cc7846fd3 100644 --- a/src/lib/orderman/ilink3/ILink3Utils.cpp +++ b/src/lib/orderman/ilink3/ILink3Utils.cpp @@ -162,9 +162,9 @@ map_cust_cti(api::orderman::CTICode code) { case CTI_CODE_CTI_CODE1: return CustOrderCapacity::Membertradingfortheirownaccount; case CTI_CODE_CTI_CODE2: - return CustOrderCapacity::Clearingfirmtradingforitsproprietaryaccount; + return CustOrderCapacity::Memberfirmtradingforitsproprietaryaccount; case CTI_CODE_CTI_CODE3: - return CustOrderCapacity::Membertradingforanothermember; + return CustOrderCapacity::Membertradingforanothermemberornonmember; case CTI_CODE_CTI_CODE4: return CustOrderCapacity::Allother; default: diff --git a/src/lib/orderman/ilink3/SessionStore.cpp b/src/lib/orderman/ilink3/SessionStore.cpp index ac3eee808..fc06f00dd 100644 --- a/src/lib/orderman/ilink3/SessionStore.cpp +++ b/src/lib/orderman/ilink3/SessionStore.cpp @@ -1,5 +1,6 @@ #include "SessionStore.h" #include "lib/jetfix/store/session_name.h" +#include "lib/logging/logging.h" #include "lib/orderman/ilink3/IL3GW.h" #include "lib/orderman/ilink3/IL3SecDB.h" #include "lib/orderman/orderman_utils/ExecutionReport.h" @@ -108,12 +109,14 @@ static void save_raw_msg( } void save_session(std::string const &path, Session const &session) { + LOG(OrderMan, Info, "SessionStore save_session (to file) path: {}", path); std::ofstream f(path); f << session.uuid << " " << session.to_cme << " " << session.from_cme << std::endl; } Session load_session(jetfix::SessionName const &sn, std::string const &path) { + LOG(OrderMan, Info, "SessionStore load_session (from file) path: {}", path); auto result = Session{sn.as_uint64_t, 0, 0}; if (boost::filesystem::exists(path)) { std::ifstream f(path); diff --git a/src/lib/orderman/ilink3/generated/AvgPxInd.h b/src/lib/orderman/ilink3/generated/AvgPxInd.h index ae2811470..5a0677067 100644 --- a/src/lib/orderman/ilink3/generated/AvgPxInd.h +++ b/src/lib/orderman/ilink3/generated/AvgPxInd.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_AVGPXIND_H_ #define _ILINKBINARY_AVGPXIND_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,53 +25,51 @@ namespace iLinkBinary { -class AvgPxInd { - public: - enum Value { - NoAveragePricing = (std::uint8_t)0, - TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID = - (std::uint8_t)1, - TradeispartofaNotionalValueAveragePriceGroup = (std::uint8_t)3, - NULL_VALUE = (std::uint8_t)255 - }; +class AvgPxInd +{ +public: + enum Value + { + NoAveragePricing = static_cast(0), + TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID = static_cast(1), + TradeispartofaNotionalValueAveragePriceGroup = static_cast(3), + NULL_VALUE = static_cast(255) + }; - static AvgPxInd::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return NoAveragePricing; - case 1: - return TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID; - case 3: - return TradeispartofaNotionalValueAveragePriceGroup; - case 255: - return NULL_VALUE; - } + static AvgPxInd::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return NoAveragePricing; + case static_cast(1): return TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID; + case static_cast(3): return TradeispartofaNotionalValueAveragePriceGroup; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum AvgPxInd [E103]"); - } + throw std::runtime_error("unknown value for enum AvgPxInd [E103]"); + } - static const char *c_str(const AvgPxInd::Value value) { - switch (value) { - case NoAveragePricing: - return "NoAveragePricing"; - case TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID: - return "TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID"; - case TradeispartofaNotionalValueAveragePriceGroup: - return "TradeispartofaNotionalValueAveragePriceGroup"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const AvgPxInd::Value value) + { + switch (value) + { + case NoAveragePricing: return "NoAveragePricing"; + case TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID: return "TradeispartofanAveragePriceGroupIdentifiedbytheAvgPxGrpID"; + case TradeispartofaNotionalValueAveragePriceGroup: return "TradeispartofaNotionalValueAveragePriceGroup"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum AvgPxInd [E103]:"); - } + throw std::runtime_error("unknown value for enum AvgPxInd [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, AvgPxInd::Value m) { - return os << AvgPxInd::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, AvgPxInd::Value m) + { + return os << AvgPxInd::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/BooleanFlag.h b/src/lib/orderman/ilink3/generated/BooleanFlag.h index 00ee6664e..b361cc5ea 100644 --- a/src/lib/orderman/ilink3/generated/BooleanFlag.h +++ b/src/lib/orderman/ilink3/generated/BooleanFlag.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_BOOLEANFLAG_H_ #define _ILINKBINARY_BOOLEANFLAG_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class BooleanFlag { - public: - enum Value { - False = (std::uint8_t)0, - True = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class BooleanFlag +{ +public: + enum Value + { + False = static_cast(0), + True = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static BooleanFlag::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return False; - case 1: - return True; - case 255: - return NULL_VALUE; - } + static BooleanFlag::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return False; + case static_cast(1): return True; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum BooleanFlag [E103]"); - } + throw std::runtime_error("unknown value for enum BooleanFlag [E103]"); + } - static const char *c_str(const BooleanFlag::Value value) { - switch (value) { - case False: - return "False"; - case True: - return "True"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const BooleanFlag::Value value) + { + switch (value) + { + case False: return "False"; + case True: return "True"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum BooleanFlag [E103]:"); - } + throw std::runtime_error("unknown value for enum BooleanFlag [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, BooleanFlag::Value m) { - return os << BooleanFlag::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, BooleanFlag::Value m) + { + return os << BooleanFlag::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/BooleanNULL.h b/src/lib/orderman/ilink3/generated/BooleanNULL.h index e9693535d..3c28c3df2 100644 --- a/src/lib/orderman/ilink3/generated/BooleanNULL.h +++ b/src/lib/orderman/ilink3/generated/BooleanNULL.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_BOOLEANNULL_H_ #define _ILINKBINARY_BOOLEANNULL_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class BooleanNULL { - public: - enum Value { - False = (std::uint8_t)0, - True = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class BooleanNULL +{ +public: + enum Value + { + False = static_cast(0), + True = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static BooleanNULL::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return False; - case 1: - return True; - case 255: - return NULL_VALUE; - } + static BooleanNULL::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return False; + case static_cast(1): return True; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum BooleanNULL [E103]"); - } + throw std::runtime_error("unknown value for enum BooleanNULL [E103]"); + } - static const char *c_str(const BooleanNULL::Value value) { - switch (value) { - case False: - return "False"; - case True: - return "True"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const BooleanNULL::Value value) + { + switch (value) + { + case False: return "False"; + case True: return "True"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum BooleanNULL [E103]:"); - } + throw std::runtime_error("unknown value for enum BooleanNULL [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, BooleanNULL::Value m) { - return os << BooleanNULL::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, BooleanNULL::Value m) + { + return os << BooleanNULL::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/BusinessReject521.h b/src/lib/orderman/ilink3/generated/BusinessReject521.h index 344a05e39..5db006073 100644 --- a/src/lib/orderman/ilink3/generated/BusinessReject521.h +++ b/src/lib/orderman/ilink3/generated/BusinessReject521.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1789 +86,1965 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class BusinessReject521 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class BusinessReject521 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(330); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(521); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - BusinessReject521() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - BusinessReject521( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - BusinessReject521(char *buffer, const std::uint64_t bufferLength) - : BusinessReject521( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + BusinessReject521() = default; - BusinessReject521( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : BusinessReject521( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + BusinessReject521( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)330; - } + BusinessReject521(char *buffer, const std::uint64_t bufferLength) : + BusinessReject521(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + BusinessReject521( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + BusinessReject521(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)521; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(330); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(521); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "j"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - BusinessReject521 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = BusinessReject521( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "j"; + } - BusinessReject521 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + BusinessReject521 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = BusinessReject521(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = BusinessReject521( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + BusinessReject521 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - BusinessReject521 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = BusinessReject521( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = BusinessReject521( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + BusinessReject521 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = BusinessReject521(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + BusinessReject521 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - BusinessReject521 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + BusinessReject521 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - BusinessReject521 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + BusinessReject521 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - BusinessReject521 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + BusinessReject521 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } + static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT + { + return 58; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= textSinceVersion(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 256; + } - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 256; + } - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - BusinessReject521 &text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } + BusinessReject521 &text(const std::uint64_t index, const char value) + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } + std::uint64_t getText(char *const dst, const std::uint64_t length) const + { + if (length > 256) + { + throw std::runtime_error("length too large for getText [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - BusinessReject521 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } + BusinessReject521 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); + return *this; + } - SBE_NODISCARD std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); + std::string getTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTextAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - BusinessReject521 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + #if __cplusplus >= 201703L + BusinessReject521 &putText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - BusinessReject521 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + return *this; + } + #else + BusinessReject521 &putText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 268; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); + return (val); + } - BusinessReject521 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + BusinessReject521 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast(length)); + return length; + } - BusinessReject521 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 20); - return *this; - } + BusinessReject521 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - BusinessReject521 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + BusinessReject521 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#else - BusinessReject521 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + BusinessReject521 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 288; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 288; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 288, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 288, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - BusinessReject521 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 288, &val, sizeof(std::uint64_t)); - return *this; - } + BusinessReject521 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 288, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 296; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 296; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 296, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 296, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - BusinessReject521 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 296, &val, sizeof(std::uint64_t)); - return *this; - } + BusinessReject521 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 296, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *BusinessRejectRefIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *BusinessRejectRefIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t businessRejectRefIDId() SBE_NOEXCEPT { - return 379; - } + static SBE_CONSTEXPR std::uint16_t businessRejectRefIDId() SBE_NOEXCEPT + { + return 379; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - businessRejectRefIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t businessRejectRefIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool businessRejectRefIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool businessRejectRefIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= businessRejectRefIDSinceVersion(); + return m_actingVersion >= businessRejectRefIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - businessRejectRefIDEncodingOffset() SBE_NOEXCEPT { - return 304; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t businessRejectRefIDEncodingOffset() SBE_NOEXCEPT + { + return 304; + } - static SBE_CONSTEXPR std::uint64_t - businessRejectRefIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t businessRejectRefIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t - businessRejectRefIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t businessRejectRefIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - businessRejectRefIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t businessRejectRefIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - businessRejectRefIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t businessRejectRefIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t businessRejectRefID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 304, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t businessRejectRefID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 304, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - BusinessReject521 & - businessRejectRefID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 304, &val, sizeof(std::uint64_t)); - return *this; - } + BusinessReject521 &businessRejectRefID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 304, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 312; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 312; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 312; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 312; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 312; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 312; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 312 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 312 + (index * 1), sizeof(char)); + return (val); + } - BusinessReject521 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + BusinessReject521 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 312 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 312 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 312, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 312, sizeof(char) * static_cast(length)); + return length; + } - BusinessReject521 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 312, src, sizeof(char) * 5); - return *this; - } + BusinessReject521 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 312, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 312; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 312; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 312; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 312; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - BusinessReject521 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + BusinessReject521 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 312, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 312 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 312, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 312 + start] = 0; + } - return *this; - } -#else - BusinessReject521 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + BusinessReject521 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 312, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 312 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 312, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 312 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - RefSeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RefSeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t refSeqNumId() SBE_NOEXCEPT { return 45; } + static SBE_CONSTEXPR std::uint16_t refSeqNumId() SBE_NOEXCEPT + { + return 45; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - refSeqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t refSeqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool refSeqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool refSeqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= refSeqNumSinceVersion(); + return m_actingVersion >= refSeqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - refSeqNumEncodingOffset() SBE_NOEXCEPT { - return 317; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t refSeqNumEncodingOffset() SBE_NOEXCEPT + { + return 317; + } - static SBE_CONSTEXPR std::uint32_t refSeqNumNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t refSeqNumNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t refSeqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t refSeqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t refSeqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t refSeqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t refSeqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t refSeqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t refSeqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 317, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t refSeqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 317, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - BusinessReject521 &refSeqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 317, &val, sizeof(std::uint32_t)); - return *this; - } + BusinessReject521 &refSeqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 317, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - RefTagIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RefTagIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t refTagIDId() SBE_NOEXCEPT { return 371; } + static SBE_CONSTEXPR std::uint16_t refTagIDId() SBE_NOEXCEPT + { + return 371; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - refTagIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t refTagIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool refTagIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool refTagIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= refTagIDSinceVersion(); + return m_actingVersion >= refTagIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - refTagIDEncodingOffset() SBE_NOEXCEPT { - return 321; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t refTagIDEncodingOffset() SBE_NOEXCEPT + { + return 321; + } - static SBE_CONSTEXPR std::uint16_t refTagIDNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t refTagIDNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t refTagIDMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t refTagIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t refTagIDMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t refTagIDMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t refTagIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t refTagIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t refTagID() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 321, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t refTagID() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 321, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - BusinessReject521 &refTagID(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 321, &val, sizeof(std::uint16_t)); - return *this; - } + BusinessReject521 &refTagID(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 321, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *BusinessRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *BusinessRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t businessRejectReasonId() SBE_NOEXCEPT { - return 380; - } + static SBE_CONSTEXPR std::uint16_t businessRejectReasonId() SBE_NOEXCEPT + { + return 380; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - businessRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t businessRejectReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool businessRejectReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool businessRejectReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= businessRejectReasonSinceVersion(); + return m_actingVersion >= businessRejectReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - businessRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 323; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t businessRejectReasonEncodingOffset() SBE_NOEXCEPT + { + return 323; + } - static SBE_CONSTEXPR std::uint16_t - businessRejectReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t businessRejectReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t - businessRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t businessRejectReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t - businessRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t businessRejectReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - businessRejectReasonEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t businessRejectReasonEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t businessRejectReason() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 323, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t businessRejectReason() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 323, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - BusinessReject521 & - businessRejectReason(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 323, &val, sizeof(std::uint16_t)); - return *this; - } + BusinessReject521 &businessRejectReason(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 323, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - RefMsgTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RefMsgTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t refMsgTypeId() SBE_NOEXCEPT { - return 372; - } + static SBE_CONSTEXPR std::uint16_t refMsgTypeId() SBE_NOEXCEPT + { + return 372; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - refMsgTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t refMsgTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool refMsgTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool refMsgTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= refMsgTypeSinceVersion(); + return m_actingVersion >= refMsgTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - refMsgTypeEncodingOffset() SBE_NOEXCEPT { - return 325; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t refMsgTypeEncodingOffset() SBE_NOEXCEPT + { + return 325; + } - static SBE_CONSTEXPR char refMsgTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char refMsgTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char refMsgTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char refMsgTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char refMsgTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char refMsgTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t refMsgTypeEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t refMsgTypeEncodingLength() SBE_NOEXCEPT + { + return 2; + } - static SBE_CONSTEXPR std::uint64_t refMsgTypeLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t refMsgTypeLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD const char *refMsgType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 325; - } + SBE_NODISCARD const char *refMsgType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 325; + } - SBE_NODISCARD char *refMsgType() SBE_NOEXCEPT { - return m_buffer + m_offset + 325; - } + SBE_NODISCARD char *refMsgType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 325; + } - SBE_NODISCARD char refMsgType(const std::uint64_t index) const { - if (index >= 2) { - throw std::runtime_error("index out of range for refMsgType [E104]"); - } + SBE_NODISCARD char refMsgType(const std::uint64_t index) const + { + if (index >= 2) + { + throw std::runtime_error("index out of range for refMsgType [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 325 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 325 + (index * 1), sizeof(char)); + return (val); + } - BusinessReject521 &refMsgType(const std::uint64_t index, const char value) { - if (index >= 2) { - throw std::runtime_error("index out of range for refMsgType [E105]"); - } + BusinessReject521 &refMsgType(const std::uint64_t index, const char value) + { + if (index >= 2) + { + throw std::runtime_error("index out of range for refMsgType [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 325 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 325 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getRefMsgType(char *const dst, const std::uint64_t length) const { - if (length > 2) { - throw std::runtime_error("length too large for getRefMsgType [E106]"); - } + std::uint64_t getRefMsgType(char *const dst, const std::uint64_t length) const + { + if (length > 2) + { + throw std::runtime_error("length too large for getRefMsgType [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 325, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 325, sizeof(char) * static_cast(length)); + return length; + } - BusinessReject521 &putRefMsgType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 325, src, sizeof(char) * 2); - return *this; - } + BusinessReject521 &putRefMsgType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 325, src, sizeof(char) * 2); + return *this; + } - BusinessReject521 & - putRefMsgType(const char value0, const char value1) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 325, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 326, &val1, sizeof(char)); + BusinessReject521 &putRefMsgType( + const char value0, + const char value1) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 325, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 326, &val1, sizeof(char)); - return *this; - } + return *this; + } - SBE_NODISCARD std::string getRefMsgTypeAsString() const { - const char *buffer = m_buffer + m_offset + 325; - size_t length = 0; + SBE_NODISCARD std::string getRefMsgTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 325; + std::size_t length = 0; - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getRefMsgTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getRefMsgTypeAsString(); + std::string getRefMsgTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getRefMsgTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getRefMsgTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 325; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getRefMsgTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 325; + std::size_t length = 0; - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - BusinessReject521 &putRefMsgType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error("string too large for putRefMsgType [E106]"); - } + #if __cplusplus >= 201703L + BusinessReject521 &putRefMsgType(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putRefMsgType [E106]"); + } - std::memcpy(m_buffer + m_offset + 325, str.data(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { - m_buffer[m_offset + 325 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 325, str.data(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 325 + start] = 0; + } - return *this; - } -#else - BusinessReject521 &putRefMsgType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error("string too large for putRefMsgType [E106]"); - } + return *this; + } + #else + BusinessReject521 &putRefMsgType(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putRefMsgType [E106]"); + } - std::memcpy(m_buffer + m_offset + 325, str.c_str(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { - m_buffer[m_offset + 325 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 325, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 325 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 327; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 327; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint8_t)); + return (val); + } - BusinessReject521 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 327, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + BusinessReject521 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 327, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 328; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 328; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdInd::Value manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 328, sizeof(std::uint8_t)); - return ManualOrdInd::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 328, sizeof(std::uint8_t)); + return (val); + } - BusinessReject521 & - manualOrderIndicator(const ManualOrdInd::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 328, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdInd::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 328, sizeof(std::uint8_t)); + return ManualOrdInd::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + BusinessReject521 &manualOrderIndicator(const ManualOrdInd::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 328, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 329; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 329; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint8_t)); + return (val); + } - BusinessReject521 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 329, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, BusinessReject521 _writer) { - BusinessReject521 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "BusinessReject521", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + BusinessReject521 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 329, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, BusinessReject521 _writer) +{ + BusinessReject521 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << '{'; + builder << R"("Name": "BusinessReject521", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << ", "; + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("BusinessRejectRefID": )"; - builder << +writer.businessRejectRefID(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("RefSeqNum": )"; - builder << +writer.refSeqNum(); + builder << ", "; + builder << R"("BusinessRejectRefID": )"; + builder << +writer.businessRejectRefID(); - builder << ", "; - builder << R"("RefTagID": )"; - builder << +writer.refTagID(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("BusinessRejectReason": )"; - builder << +writer.businessRejectReason(); + builder << ", "; + builder << R"("RefSeqNum": )"; + builder << +writer.refSeqNum(); - builder << ", "; - builder << R"("RefMsgType": )"; - builder << '"' << writer.getRefMsgTypeAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("RefTagID": )"; + builder << +writer.refTagID(); - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("BusinessRejectReason": )"; + builder << +writer.businessRejectReason(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("RefMsgType": )"; + builder << '"' << + writer.getRefMsgTypeAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; - builder << '}'; + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - return builder; - } + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - void skip() {} + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ClearingAcctType.h b/src/lib/orderman/ilink3/generated/ClearingAcctType.h index a10712df9..ae3006427 100644 --- a/src/lib/orderman/ilink3/generated/ClearingAcctType.h +++ b/src/lib/orderman/ilink3/generated/ClearingAcctType.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_CLEARINGACCTTYPE_H_ #define _ILINKBINARY_CLEARINGACCTTYPE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,49 +25,48 @@ namespace iLinkBinary { -class ClearingAcctType { - public: - enum Value { - Customer = (std::uint8_t)0, - Firm = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class ClearingAcctType +{ +public: + enum Value + { + Customer = static_cast(0), + Firm = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static ClearingAcctType::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Customer; - case 1: - return Firm; - case 255: - return NULL_VALUE; - } + static ClearingAcctType::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Customer; + case static_cast(1): return Firm; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum ClearingAcctType [E103]"); - } + throw std::runtime_error("unknown value for enum ClearingAcctType [E103]"); + } - static const char *c_str(const ClearingAcctType::Value value) { - switch (value) { - case Customer: - return "Customer"; - case Firm: - return "Firm"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ClearingAcctType::Value value) + { + switch (value) + { + case Customer: return "Customer"; + case Firm: return "Firm"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum ClearingAcctType [E103]:"); - } + throw std::runtime_error("unknown value for enum ClearingAcctType [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, ClearingAcctType::Value m) { - return os << ClearingAcctType::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ClearingAcctType::Value m) + { + return os << ClearingAcctType::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/CmtaGiveUpCD.h b/src/lib/orderman/ilink3/generated/CmtaGiveUpCD.h index a073cfdd1..3a96a4b98 100644 --- a/src/lib/orderman/ilink3/generated/CmtaGiveUpCD.h +++ b/src/lib/orderman/ilink3/generated/CmtaGiveUpCD.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_CMTAGIVEUPCD_H_ #define _ILINKBINARY_CMTAGIVEUPCD_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,43 +25,48 @@ namespace iLinkBinary { -class CmtaGiveUpCD { - public: - enum Value { GiveUp = (char)71, SGXoffset = (char)83, NULL_VALUE = (char)0 }; +class CmtaGiveUpCD +{ +public: + enum Value + { + GiveUp = static_cast(71), + SGXoffset = static_cast(83), + NULL_VALUE = static_cast(0x00) + }; - static CmtaGiveUpCD::Value get(const char value) { - switch (value) { - case 71: - return GiveUp; - case 83: - return SGXoffset; - case 0: - return NULL_VALUE; - } + static CmtaGiveUpCD::Value get(const char value) + { + switch (value) + { + case static_cast(71): return GiveUp; + case static_cast(83): return SGXoffset; + case static_cast(0x00): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum CmtaGiveUpCD [E103]"); - } + throw std::runtime_error("unknown value for enum CmtaGiveUpCD [E103]"); + } - static const char *c_str(const CmtaGiveUpCD::Value value) { - switch (value) { - case GiveUp: - return "GiveUp"; - case SGXoffset: - return "SGXoffset"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const CmtaGiveUpCD::Value value) + { + switch (value) + { + case GiveUp: return "GiveUp"; + case SGXoffset: return "SGXoffset"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum CmtaGiveUpCD [E103]:"); - } + throw std::runtime_error("unknown value for enum CmtaGiveUpCD [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, CmtaGiveUpCD::Value m) { - return os << CmtaGiveUpCD::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, CmtaGiveUpCD::Value m) + { + return os << CmtaGiveUpCD::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/CustOrdHandlInst.h b/src/lib/orderman/ilink3/generated/CustOrdHandlInst.h index c8af0f006..40e7598f4 100644 --- a/src/lib/orderman/ilink3/generated/CustOrdHandlInst.h +++ b/src/lib/orderman/ilink3/generated/CustOrdHandlInst.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_CUSTORDHANDLINST_H_ #define _ILINKBINARY_CUSTORDHANDLINST_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,69 +25,60 @@ namespace iLinkBinary { -class CustOrdHandlInst { - public: - enum Value { - FCMprovidedscreen = (char)67, - Otherprovidedscreen = (char)68, - FCMAPIorFIX = (char)71, - AlgoEngine = (char)72, - DeskElectronic = (char)87, - ClientElectronic = (char)89, - NULL_VALUE = (char)0 - }; +class CustOrdHandlInst +{ +public: + enum Value + { + FCMprovidedscreen = static_cast(67), + Otherprovidedscreen = static_cast(68), + FCMAPIorFIX = static_cast(71), + AlgoEngine = static_cast(72), + DeskElectronic = static_cast(87), + ClientElectronic = static_cast(89), + NULL_VALUE = static_cast(48) + }; - static CustOrdHandlInst::Value get(const char value) { - switch (value) { - case 67: - return FCMprovidedscreen; - case 68: - return Otherprovidedscreen; - case 71: - return FCMAPIorFIX; - case 72: - return AlgoEngine; - case 87: - return DeskElectronic; - case 89: - return ClientElectronic; - case 0: - return NULL_VALUE; - } + static CustOrdHandlInst::Value get(const char value) + { + switch (value) + { + case static_cast(67): return FCMprovidedscreen; + case static_cast(68): return Otherprovidedscreen; + case static_cast(71): return FCMAPIorFIX; + case static_cast(72): return AlgoEngine; + case static_cast(87): return DeskElectronic; + case static_cast(89): return ClientElectronic; + case static_cast(48): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum CustOrdHandlInst [E103]"); - } + throw std::runtime_error("unknown value for enum CustOrdHandlInst [E103]"); + } - static const char *c_str(const CustOrdHandlInst::Value value) { - switch (value) { - case FCMprovidedscreen: - return "FCMprovidedscreen"; - case Otherprovidedscreen: - return "Otherprovidedscreen"; - case FCMAPIorFIX: - return "FCMAPIorFIX"; - case AlgoEngine: - return "AlgoEngine"; - case DeskElectronic: - return "DeskElectronic"; - case ClientElectronic: - return "ClientElectronic"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const CustOrdHandlInst::Value value) + { + switch (value) + { + case FCMprovidedscreen: return "FCMprovidedscreen"; + case Otherprovidedscreen: return "Otherprovidedscreen"; + case FCMAPIorFIX: return "FCMAPIorFIX"; + case AlgoEngine: return "AlgoEngine"; + case DeskElectronic: return "DeskElectronic"; + case ClientElectronic: return "ClientElectronic"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum CustOrdHandlInst [E103]:"); - } + throw std::runtime_error("unknown value for enum CustOrdHandlInst [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, CustOrdHandlInst::Value m) { - return os << CustOrdHandlInst::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, CustOrdHandlInst::Value m) + { + return os << CustOrdHandlInst::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/CustOrderCapacity.h b/src/lib/orderman/ilink3/generated/CustOrderCapacity.h index 8d495d841..524f0a634 100644 --- a/src/lib/orderman/ilink3/generated/CustOrderCapacity.h +++ b/src/lib/orderman/ilink3/generated/CustOrderCapacity.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_CUSTORDERCAPACITY_H_ #define _ILINKBINARY_CUSTORDERCAPACITY_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,59 +25,54 @@ namespace iLinkBinary { -class CustOrderCapacity { - public: - enum Value { - Membertradingfortheirownaccount = (std::uint8_t)1, - Clearingfirmtradingforitsproprietaryaccount = (std::uint8_t)2, - Membertradingforanothermember = (std::uint8_t)3, - Allother = (std::uint8_t)4, - NULL_VALUE = (std::uint8_t)255 - }; +class CustOrderCapacity +{ +public: + enum Value + { + Membertradingfortheirownaccount = static_cast(1), + Memberfirmtradingforitsproprietaryaccount = static_cast(2), + Membertradingforanothermemberornonmember = static_cast(3), + Allother = static_cast(4), + NULL_VALUE = static_cast(255) + }; - static CustOrderCapacity::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return Membertradingfortheirownaccount; - case 2: - return Clearingfirmtradingforitsproprietaryaccount; - case 3: - return Membertradingforanothermember; - case 4: - return Allother; - case 255: - return NULL_VALUE; - } + static CustOrderCapacity::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return Membertradingfortheirownaccount; + case static_cast(2): return Memberfirmtradingforitsproprietaryaccount; + case static_cast(3): return Membertradingforanothermemberornonmember; + case static_cast(4): return Allother; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum CustOrderCapacity [E103]"); - } + throw std::runtime_error("unknown value for enum CustOrderCapacity [E103]"); + } - static const char *c_str(const CustOrderCapacity::Value value) { - switch (value) { - case Membertradingfortheirownaccount: - return "Membertradingfortheirownaccount"; - case Clearingfirmtradingforitsproprietaryaccount: - return "Clearingfirmtradingforitsproprietaryaccount"; - case Membertradingforanothermember: - return "Membertradingforanothermember"; - case Allother: - return "Allother"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const CustOrderCapacity::Value value) + { + switch (value) + { + case Membertradingfortheirownaccount: return "Membertradingfortheirownaccount"; + case Memberfirmtradingforitsproprietaryaccount: return "Memberfirmtradingforitsproprietaryaccount"; + case Membertradingforanothermemberornonmember: return "Membertradingforanothermemberornonmember"; + case Allother: return "Allother"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum CustOrderCapacity [E103]:"); - } + throw std::runtime_error("unknown value for enum CustOrderCapacity [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, CustOrderCapacity::Value m) { - return os << CustOrderCapacity::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, CustOrderCapacity::Value m) + { + return os << CustOrderCapacity::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/DATA.h b/src/lib/orderman/ilink3/generated/DATA.h index aae8dfffd..2fdbfdba7 100644 --- a/src/lib/orderman/ilink3/generated/DATA.h +++ b/src/lib/orderman/ilink3/generated/DATA.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,206 +86,258 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace iLinkBinary { -class DATA { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class DATA +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - DATA() = default; + DATA() = default; - DATA( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_actingVersion(actingVersion) { - if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + -1) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + DATA( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_actingVersion(actingVersion) + { + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + -1) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - DATA( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : DATA(buffer, 0, bufferLength, actingVersion) {} + DATA( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + DATA(buffer, 0, bufferLength, actingVersion) + { + } - DATA(char *buffer, const std::uint64_t bufferLength) - : DATA(buffer, 0, bufferLength, sbeSchemaVersion()) {} + DATA( + char *buffer, + const std::uint64_t bufferLength) : + DATA(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - DATA &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = DATA(buffer, offset, bufferLength, actingVersion); - } + DATA &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = DATA(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return -1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static const char * - lengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *lengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lengthId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t lengthId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lengthSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lengthSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lengthInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lengthInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lengthSinceVersion(); + return m_actingVersion >= lengthSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lengthEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lengthEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t lengthNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t lengthNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t lengthMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t lengthMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t lengthMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t lengthMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t lengthEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t lengthEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t length() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t length() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - DATA &length(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); - return *this; - } + DATA &length(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - varDataMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *varDataMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t varDataId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t varDataId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - varDataSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t varDataSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool varDataInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool varDataInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= varDataSinceVersion(); + return m_actingVersion >= varDataSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - varDataEncodingOffset() SBE_NOEXCEPT { - return 2; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t varDataEncodingOffset() SBE_NOEXCEPT + { + return 2; + } - static SBE_CONSTEXPR char varDataNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char varDataNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char varDataMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char varDataMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char varDataMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char varDataMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t varDataEncodingLength() SBE_NOEXCEPT { - return -1; - } + static SBE_CONSTEXPR std::size_t varDataEncodingLength() SBE_NOEXCEPT + { + return -1; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, DATA writer) { - builder << '{'; - builder << R"("length": )"; - builder << +writer.length(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, DATA writer) +{ + builder << '{'; + builder << R"("length": )"; + builder << +writer.length(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/DKReason.h b/src/lib/orderman/ilink3/generated/DKReason.h index e73d00ef3..2be28325d 100644 --- a/src/lib/orderman/ilink3/generated/DKReason.h +++ b/src/lib/orderman/ilink3/generated/DKReason.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_DKREASON_H_ #define _ILINKBINARY_DKREASON_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,77 +25,66 @@ namespace iLinkBinary { -class DKReason { - public: - enum Value { - UnknownSecurity = (char)65, - WrongSide = (char)66, - QuantityExceedsOrder = (char)67, - NoMatchingOrder = (char)68, - PriceExceedsLimit = (char)69, - CalculationDifference = (char)70, - NoMatchingExecutionReport = (char)71, - Other = (char)90, - NULL_VALUE = (char)0 - }; +class DKReason +{ +public: + enum Value + { + UnknownSecurity = static_cast(65), + WrongSide = static_cast(66), + QuantityExceedsOrder = static_cast(67), + NoMatchingOrder = static_cast(68), + PriceExceedsLimit = static_cast(69), + CalculationDifference = static_cast(70), + NoMatchingExecutionReport = static_cast(71), + Other = static_cast(90), + NULL_VALUE = static_cast(48) + }; - static DKReason::Value get(const char value) { - switch (value) { - case 65: - return UnknownSecurity; - case 66: - return WrongSide; - case 67: - return QuantityExceedsOrder; - case 68: - return NoMatchingOrder; - case 69: - return PriceExceedsLimit; - case 70: - return CalculationDifference; - case 71: - return NoMatchingExecutionReport; - case 90: - return Other; - case 0: - return NULL_VALUE; - } + static DKReason::Value get(const char value) + { + switch (value) + { + case static_cast(65): return UnknownSecurity; + case static_cast(66): return WrongSide; + case static_cast(67): return QuantityExceedsOrder; + case static_cast(68): return NoMatchingOrder; + case static_cast(69): return PriceExceedsLimit; + case static_cast(70): return CalculationDifference; + case static_cast(71): return NoMatchingExecutionReport; + case static_cast(90): return Other; + case static_cast(48): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum DKReason [E103]"); - } + throw std::runtime_error("unknown value for enum DKReason [E103]"); + } - static const char *c_str(const DKReason::Value value) { - switch (value) { - case UnknownSecurity: - return "UnknownSecurity"; - case WrongSide: - return "WrongSide"; - case QuantityExceedsOrder: - return "QuantityExceedsOrder"; - case NoMatchingOrder: - return "NoMatchingOrder"; - case PriceExceedsLimit: - return "PriceExceedsLimit"; - case CalculationDifference: - return "CalculationDifference"; - case NoMatchingExecutionReport: - return "NoMatchingExecutionReport"; - case Other: - return "Other"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const DKReason::Value value) + { + switch (value) + { + case UnknownSecurity: return "UnknownSecurity"; + case WrongSide: return "WrongSide"; + case QuantityExceedsOrder: return "QuantityExceedsOrder"; + case NoMatchingOrder: return "NoMatchingOrder"; + case PriceExceedsLimit: return "PriceExceedsLimit"; + case CalculationDifference: return "CalculationDifference"; + case NoMatchingExecutionReport: return "NoMatchingExecutionReport"; + case Other: return "Other"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum DKReason [E103]:"); - } + throw std::runtime_error("unknown value for enum DKReason [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, DKReason::Value m) { - return os << DKReason::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, DKReason::Value m) + { + return os << DKReason::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/Decimal32NULL.h b/src/lib/orderman/ilink3/generated/Decimal32NULL.h index 4b34559bb..f936295e2 100644 --- a/src/lib/orderman/ilink3/generated/Decimal32NULL.h +++ b/src/lib/orderman/ilink3/generated/Decimal32NULL.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,226 +86,276 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace iLinkBinary { -class Decimal32NULL { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class Decimal32NULL +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - Decimal32NULL() = default; + Decimal32NULL() = default; - Decimal32NULL( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_actingVersion(actingVersion) { - if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 5) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + Decimal32NULL( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_actingVersion(actingVersion) + { + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 5) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - Decimal32NULL( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : Decimal32NULL(buffer, 0, bufferLength, actingVersion) {} + Decimal32NULL( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + Decimal32NULL(buffer, 0, bufferLength, actingVersion) + { + } - Decimal32NULL(char *buffer, const std::uint64_t bufferLength) - : Decimal32NULL(buffer, 0, bufferLength, sbeSchemaVersion()) {} + Decimal32NULL( + char *buffer, + const std::uint64_t bufferLength) : + Decimal32NULL(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - Decimal32NULL &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = Decimal32NULL(buffer, offset, bufferLength, actingVersion); - } + Decimal32NULL &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = Decimal32NULL(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static const char * - mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mantissaSinceVersion(); + return m_actingVersion >= mantissaSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mantissaEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mantissaEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::int32_t mantissaNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t mantissaNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t mantissaMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t mantissaMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t mantissaMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t mantissaMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t mantissa() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t mantissa() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - Decimal32NULL &mantissa(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int32_t)); - return *this; - } + Decimal32NULL &mantissa(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t exponentId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t exponentId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - exponentSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t exponentSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool exponentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool exponentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= exponentSinceVersion(); + return m_actingVersion >= exponentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - exponentEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t exponentEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t exponent() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t exponent() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::int8_t)); + return (val); + } - Decimal32NULL &exponent(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::int8_t)); - return *this; - } + Decimal32NULL &exponent(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::int8_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, Decimal32NULL writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, Decimal32NULL writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << ", "; - builder << R"("exponent": )"; - builder << +writer.exponent(); + builder << ", "; + builder << R"("exponent": )"; + builder << +writer.exponent(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/Decimal64NULL.h b/src/lib/orderman/ilink3/generated/Decimal64NULL.h index e090cf66e..ef20dc82e 100644 --- a/src/lib/orderman/ilink3/generated/Decimal64NULL.h +++ b/src/lib/orderman/ilink3/generated/Decimal64NULL.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,226 +86,286 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace iLinkBinary { -class Decimal64NULL { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class Decimal64NULL +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - Decimal64NULL() = default; + Decimal64NULL() = default; - Decimal64NULL( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_actingVersion(actingVersion) { - if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 9) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + Decimal64NULL( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_actingVersion(actingVersion) + { + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 9) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - Decimal64NULL( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : Decimal64NULL(buffer, 0, bufferLength, actingVersion) {} + Decimal64NULL( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + Decimal64NULL(buffer, 0, bufferLength, actingVersion) + { + } - Decimal64NULL(char *buffer, const std::uint64_t bufferLength) - : Decimal64NULL(buffer, 0, bufferLength, sbeSchemaVersion()) {} + Decimal64NULL( + char *buffer, + const std::uint64_t bufferLength) : + Decimal64NULL(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - Decimal64NULL &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = Decimal64NULL(buffer, offset, bufferLength, actingVersion); - } + Decimal64NULL &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = Decimal64NULL(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static const char * - mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mantissaSinceVersion(); + return m_actingVersion >= mantissaSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mantissaEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mantissaEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT { - return 9223372036854775807L; - } + static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT + { + return INT64_C(9223372036854775807); + } - static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT { - return -9223372036854775807L; - } + static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT + { + return INT64_C(-9223372036854775807); + } - static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT { - return 9223372036854775807L; - } + static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT + { + return INT64_C(9223372036854775807); + } - static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::int64_t mantissa() const SBE_NOEXCEPT { - std::int64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::int64_t mantissa() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return INT64_C(9223372036854775807); + } - Decimal64NULL &mantissa(const std::int64_t value) SBE_NOEXCEPT { - std::int64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int64_t)); - return *this; - } + std::int64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SBE_NODISCARD static const char * - exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + Decimal64NULL &mantissa(const std::int64_t value) SBE_NOEXCEPT + { + std::int64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int64_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t exponentId() SBE_NOEXCEPT { return -1; } + SBE_NODISCARD static const char *exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - exponentSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t exponentId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool exponentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t exponentSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool exponentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= exponentSinceVersion(); + return m_actingVersion >= exponentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - exponentEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t exponentEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t exponent() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t exponent() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(127); + } - Decimal64NULL &exponent(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::int8_t)); - return *this; - } + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::int8_t)); + return (val); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, Decimal64NULL writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); + Decimal64NULL &exponent(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::int8_t)); + return *this; + } - builder << ", "; - builder << R"("exponent": )"; - builder << +writer.exponent(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, Decimal64NULL writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << '}'; + builder << ", "; + builder << R"("exponent": )"; + builder << +writer.exponent(); + + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/Establish503.h b/src/lib/orderman/ilink3/generated/Establish503.h index df6839d0b..261b92fac 100644 --- a/src/lib/orderman/ilink3/generated/Establish503.h +++ b/src/lib/orderman/ilink3/generated/Establish503.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2298 +86,2421 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class Establish503 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class Establish503 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(132); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(503); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - Establish503() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - Establish503( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - Establish503(char *buffer, const std::uint64_t bufferLength) - : Establish503( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + Establish503() = default; - Establish503( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : Establish503( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + Establish503( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)132; - } + Establish503(char *buffer, const std::uint64_t bufferLength) : + Establish503(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + Establish503( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + Establish503(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)503; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(132); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(503); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "Establish"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - Establish503 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = Establish503( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "Establish"; + } - Establish503 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + Establish503 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = Establish503(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = Establish503( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + Establish503 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - Establish503 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = Establish503( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = Establish503( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + Establish503 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = Establish503(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + Establish503 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - Establish503 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + Establish503 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - HMACVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t hMACVersionId() SBE_NOEXCEPT { - return 39003; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hMACVersionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool hMACVersionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *HMACVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t hMACVersionId() SBE_NOEXCEPT + { + return 39003; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hMACVersionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool hMACVersionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hMACVersionSinceVersion(); + return m_actingVersion >= hMACVersionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hMACVersionEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hMACVersionEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t hMACVersionLength() SBE_NOEXCEPT { - return 13; - } + static SBE_CONSTEXPR std::uint64_t hMACVersionLength() SBE_NOEXCEPT + { + return 13; + } - SBE_NODISCARD const char *hMACVersion() const { - static const std::uint8_t hMACVersionValues[] = { - 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54}; + SBE_NODISCARD const char *hMACVersion() const + { + static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54, 0 }; - return (const char *)hMACVersionValues; - } + return (const char *)hMACVersionValues; + } - SBE_NODISCARD char hMACVersion(const std::uint64_t index) const { - static const std::uint8_t hMACVersionValues[] = { - 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54}; + SBE_NODISCARD char hMACVersion(const std::uint64_t index) const + { + static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54, 0 }; - return (char)hMACVersionValues[index]; - } + return (char)hMACVersionValues[index]; + } - std::uint64_t getHMACVersion(char *dst, const std::uint64_t length) const { - static std::uint8_t hMACVersionValues[] = {67, 77, 69, 45, 49, 45, 83, - 72, 65, 45, 50, 53, 54}; - std::uint64_t bytesToCopy = length < sizeof(hMACVersionValues) - ? length - : sizeof(hMACVersionValues); + std::uint64_t getHMACVersion(char *dst, const std::uint64_t length) const + { + static std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 }; + std::uint64_t bytesToCopy = length < sizeof(hMACVersionValues) ? length : sizeof(hMACVersionValues); - std::memcpy(dst, hMACVersionValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, hMACVersionValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getHMACVersionAsString() const { - static const std::uint8_t HMACVersionValues[] = { - 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54}; + std::string getHMACVersionAsString() const + { + static const std::uint8_t HMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 }; - return std::string((const char *)HMACVersionValues, 13); - } + return std::string((const char *)HMACVersionValues, 13); + } - std::string getHMACVersionAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getHMACVersionAsString(); + std::string getHMACVersionAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getHMACVersionAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - HMACSignatureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HMACSignatureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t hMACSignatureId() SBE_NOEXCEPT { - return 39005; - } + static SBE_CONSTEXPR std::uint16_t hMACSignatureId() SBE_NOEXCEPT + { + return 39005; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hMACSignatureSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hMACSignatureSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool hMACSignatureInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool hMACSignatureInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hMACSignatureSinceVersion(); + return m_actingVersion >= hMACSignatureSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hMACSignatureEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hMACSignatureEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT { - return 32; - } + static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR std::uint64_t hMACSignatureLength() SBE_NOEXCEPT { - return 32; - } + static SBE_CONSTEXPR std::uint64_t hMACSignatureLength() SBE_NOEXCEPT + { + return 32; + } - SBE_NODISCARD const char *hMACSignature() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } + SBE_NODISCARD const char *hMACSignature() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char *hMACSignature() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } + SBE_NODISCARD char *hMACSignature() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char hMACSignature(const std::uint64_t index) const { - if (index >= 32) { - throw std::runtime_error( - "index out of range for hMACSignature [E104]"); - } + SBE_NODISCARD char hMACSignature(const std::uint64_t index) const + { + if (index >= 32) + { + throw std::runtime_error("index out of range for hMACSignature [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - Establish503 &hMACSignature(const std::uint64_t index, const char value) { - if (index >= 32) { - throw std::runtime_error( - "index out of range for hMACSignature [E105]"); - } + Establish503 &hMACSignature(const std::uint64_t index, const char value) + { + if (index >= 32) + { + throw std::runtime_error("index out of range for hMACSignature [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getHMACSignature(char *const dst, const std::uint64_t length) const { - if (length > 32) { - throw std::runtime_error( - "length too large for getHMACSignature [E106]"); - } + std::uint64_t getHMACSignature(char *const dst, const std::uint64_t length) const + { + if (length > 32) + { + throw std::runtime_error("length too large for getHMACSignature [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - Establish503 &putHMACSignature(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 32); - return *this; - } + Establish503 &putHMACSignature(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 32); + return *this; + } - SBE_NODISCARD std::string getHMACSignatureAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + SBE_NODISCARD std::string getHMACSignatureAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 32 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 32 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getHMACSignatureAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getHMACSignatureAsString(); + std::string getHMACSignatureAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getHMACSignatureAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getHMACSignatureAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getHMACSignatureAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 32 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 32 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Establish503 &putHMACSignature(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 32) { - throw std::runtime_error( - "string too large for putHMACSignature [E106]"); - } + #if __cplusplus >= 201703L + Establish503 &putHMACSignature(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 32) + { + throw std::runtime_error("string too large for putHMACSignature [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 32; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 32; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#else - Establish503 &putHMACSignature(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 32) { - throw std::runtime_error( - "string too large for putHMACSignature [E106]"); - } + return *this; + } + #else + Establish503 &putHMACSignature(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 32) + { + throw std::runtime_error("string too large for putHMACSignature [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 32; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 32; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AccessKeyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *AccessKeyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t accessKeyIDId() SBE_NOEXCEPT { - return 39004; - } + static SBE_CONSTEXPR std::uint16_t accessKeyIDId() SBE_NOEXCEPT + { + return 39004; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - accessKeyIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t accessKeyIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool accessKeyIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool accessKeyIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= accessKeyIDSinceVersion(); + return m_actingVersion >= accessKeyIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - accessKeyIDEncodingOffset() SBE_NOEXCEPT { - return 32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t accessKeyIDEncodingOffset() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t accessKeyIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t accessKeyIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *accessKeyID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 32; - } + SBE_NODISCARD const char *accessKeyID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 32; + } - SBE_NODISCARD char *accessKeyID() SBE_NOEXCEPT { - return m_buffer + m_offset + 32; - } + SBE_NODISCARD char *accessKeyID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 32; + } - SBE_NODISCARD char accessKeyID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for accessKeyID [E104]"); - } + SBE_NODISCARD char accessKeyID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for accessKeyID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 32 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 32 + (index * 1), sizeof(char)); + return (val); + } - Establish503 &accessKeyID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for accessKeyID [E105]"); - } + Establish503 &accessKeyID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for accessKeyID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 32 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 32 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getAccessKeyID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getAccessKeyID [E106]"); - } + std::uint64_t getAccessKeyID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getAccessKeyID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 32, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 32, sizeof(char) * static_cast(length)); + return length; + } - Establish503 &putAccessKeyID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 32, src, sizeof(char) * 20); - return *this; - } + Establish503 &putAccessKeyID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 32, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getAccessKeyIDAsString() const { - const char *buffer = m_buffer + m_offset + 32; - size_t length = 0; + SBE_NODISCARD std::string getAccessKeyIDAsString() const + { + const char *buffer = m_buffer + m_offset + 32; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getAccessKeyIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAccessKeyIDAsString(); + std::string getAccessKeyIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAccessKeyIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getAccessKeyIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 32; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAccessKeyIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 32; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Establish503 &putAccessKeyID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putAccessKeyID [E106]"); - } + #if __cplusplus >= 201703L + Establish503 &putAccessKeyID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAccessKeyID [E106]"); + } - std::memcpy(m_buffer + m_offset + 32, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 32 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 32, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 32 + start] = 0; + } - return *this; - } -#else - Establish503 &putAccessKeyID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putAccessKeyID [E106]"); - } + return *this; + } + #else + Establish503 &putAccessKeyID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAccessKeyID [E106]"); + } - std::memcpy(m_buffer + m_offset + 32, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 32 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 32, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 32 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *TradingSystemNameMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TradingSystemNameMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t tradingSystemNameId() SBE_NOEXCEPT { - return 1603; - } + static SBE_CONSTEXPR std::uint16_t tradingSystemNameId() SBE_NOEXCEPT + { + return 1603; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingSystemNameSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingSystemNameSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradingSystemNameInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingSystemNameInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingSystemNameSinceVersion(); + return m_actingVersion >= tradingSystemNameSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingSystemNameEncodingOffset() SBE_NOEXCEPT { - return 52; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingSystemNameEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR char tradingSystemNameNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char tradingSystemNameNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char tradingSystemNameMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char tradingSystemNameMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char tradingSystemNameMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char tradingSystemNameMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - tradingSystemNameEncodingLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::size_t tradingSystemNameEncodingLength() SBE_NOEXCEPT + { + return 30; + } - static SBE_CONSTEXPR std::uint64_t tradingSystemNameLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::uint64_t tradingSystemNameLength() SBE_NOEXCEPT + { + return 30; + } - SBE_NODISCARD const char *tradingSystemName() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD const char *tradingSystemName() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char *tradingSystemName() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD char *tradingSystemName() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char tradingSystemName(const std::uint64_t index) const { - if (index >= 30) { - throw std::runtime_error( - "index out of range for tradingSystemName [E104]"); - } + SBE_NODISCARD char tradingSystemName(const std::uint64_t index) const + { + if (index >= 30) + { + throw std::runtime_error("index out of range for tradingSystemName [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - Establish503 & - tradingSystemName(const std::uint64_t index, const char value) { - if (index >= 30) { - throw std::runtime_error( - "index out of range for tradingSystemName [E105]"); - } + Establish503 &tradingSystemName(const std::uint64_t index, const char value) + { + if (index >= 30) + { + throw std::runtime_error("index out of range for tradingSystemName [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getTradingSystemName(char *const dst, const std::uint64_t length) const { - if (length > 30) { - throw std::runtime_error( - "length too large for getTradingSystemName [E106]"); - } + std::uint64_t getTradingSystemName(char *const dst, const std::uint64_t length) const + { + if (length > 30) + { + throw std::runtime_error("length too large for getTradingSystemName [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - Establish503 &putTradingSystemName(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 30); - return *this; - } + Establish503 &putTradingSystemName(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 30); + return *this; + } - SBE_NODISCARD std::string getTradingSystemNameAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + SBE_NODISCARD std::string getTradingSystemNameAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 30 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 30 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTradingSystemNameAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTradingSystemNameAsString(); + std::string getTradingSystemNameAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTradingSystemNameAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getTradingSystemNameAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTradingSystemNameAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 30 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 30 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Establish503 &putTradingSystemName(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putTradingSystemName [E106]"); - } + #if __cplusplus >= 201703L + Establish503 &putTradingSystemName(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putTradingSystemName [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#else - Establish503 &putTradingSystemName(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putTradingSystemName [E106]"); - } + return *this; + } + #else + Establish503 &putTradingSystemName(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putTradingSystemName [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *TradingSystemVersionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TradingSystemVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t tradingSystemVersionId() SBE_NOEXCEPT { - return 1604; - } + static SBE_CONSTEXPR std::uint16_t tradingSystemVersionId() SBE_NOEXCEPT + { + return 1604; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingSystemVersionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingSystemVersionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradingSystemVersionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingSystemVersionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingSystemVersionSinceVersion(); + return m_actingVersion >= tradingSystemVersionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingSystemVersionEncodingOffset() SBE_NOEXCEPT { - return 82; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingSystemVersionEncodingOffset() SBE_NOEXCEPT + { + return 82; + } - static SBE_CONSTEXPR char tradingSystemVersionNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char tradingSystemVersionNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char tradingSystemVersionMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char tradingSystemVersionMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char tradingSystemVersionMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char tradingSystemVersionMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - tradingSystemVersionEncodingLength() SBE_NOEXCEPT { - return 10; - } + static SBE_CONSTEXPR std::size_t tradingSystemVersionEncodingLength() SBE_NOEXCEPT + { + return 10; + } - static SBE_CONSTEXPR std::uint64_t - tradingSystemVersionLength() SBE_NOEXCEPT { - return 10; - } + static SBE_CONSTEXPR std::uint64_t tradingSystemVersionLength() SBE_NOEXCEPT + { + return 10; + } - SBE_NODISCARD const char *tradingSystemVersion() const SBE_NOEXCEPT { - return m_buffer + m_offset + 82; - } + SBE_NODISCARD const char *tradingSystemVersion() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 82; + } - SBE_NODISCARD char *tradingSystemVersion() SBE_NOEXCEPT { - return m_buffer + m_offset + 82; - } + SBE_NODISCARD char *tradingSystemVersion() SBE_NOEXCEPT + { + return m_buffer + m_offset + 82; + } - SBE_NODISCARD char tradingSystemVersion(const std::uint64_t index) const { - if (index >= 10) { - throw std::runtime_error( - "index out of range for tradingSystemVersion [E104]"); - } + SBE_NODISCARD char tradingSystemVersion(const std::uint64_t index) const + { + if (index >= 10) + { + throw std::runtime_error("index out of range for tradingSystemVersion [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 82 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 82 + (index * 1), sizeof(char)); + return (val); + } - Establish503 & - tradingSystemVersion(const std::uint64_t index, const char value) { - if (index >= 10) { - throw std::runtime_error( - "index out of range for tradingSystemVersion [E105]"); - } + Establish503 &tradingSystemVersion(const std::uint64_t index, const char value) + { + if (index >= 10) + { + throw std::runtime_error("index out of range for tradingSystemVersion [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 82 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 82 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getTradingSystemVersion(char *const dst, const std::uint64_t length) const { - if (length > 10) { - throw std::runtime_error( - "length too large for getTradingSystemVersion [E106]"); - } + std::uint64_t getTradingSystemVersion(char *const dst, const std::uint64_t length) const + { + if (length > 10) + { + throw std::runtime_error("length too large for getTradingSystemVersion [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 82, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 82, sizeof(char) * static_cast(length)); + return length; + } - Establish503 &putTradingSystemVersion(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 82, src, sizeof(char) * 10); - return *this; - } + Establish503 &putTradingSystemVersion(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 82, src, sizeof(char) * 10); + return *this; + } - SBE_NODISCARD std::string getTradingSystemVersionAsString() const { - const char *buffer = m_buffer + m_offset + 82; - size_t length = 0; + SBE_NODISCARD std::string getTradingSystemVersionAsString() const + { + const char *buffer = m_buffer + m_offset + 82; + std::size_t length = 0; - for (; length < 10 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 10 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTradingSystemVersionAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTradingSystemVersionAsString(); + std::string getTradingSystemVersionAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTradingSystemVersionAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getTradingSystemVersionAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 82; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTradingSystemVersionAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 82; + std::size_t length = 0; - for (; length < 10 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 10 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Establish503 &putTradingSystemVersion(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 10) { - throw std::runtime_error( - "string too large for putTradingSystemVersion [E106]"); - } + #if __cplusplus >= 201703L + Establish503 &putTradingSystemVersion(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 10) + { + throw std::runtime_error("string too large for putTradingSystemVersion [E106]"); + } - std::memcpy(m_buffer + m_offset + 82, str.data(), srcLength); - for (size_t start = srcLength; start < 10; ++start) { - m_buffer[m_offset + 82 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 82, str.data(), srcLength); + for (std::size_t start = srcLength; start < 10; ++start) + { + m_buffer[m_offset + 82 + start] = 0; + } - return *this; - } -#else - Establish503 &putTradingSystemVersion(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 10) { - throw std::runtime_error( - "string too large for putTradingSystemVersion [E106]"); - } + return *this; + } + #else + Establish503 &putTradingSystemVersion(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 10) + { + throw std::runtime_error("string too large for putTradingSystemVersion [E106]"); + } - std::memcpy(m_buffer + m_offset + 82, str.c_str(), srcLength); - for (size_t start = srcLength; start < 10; ++start) { - m_buffer[m_offset + 82 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 82, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 10; ++start) + { + m_buffer[m_offset + 82 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *TradingSystemVendorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TradingSystemVendorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t tradingSystemVendorId() SBE_NOEXCEPT { - return 1605; - } + static SBE_CONSTEXPR std::uint16_t tradingSystemVendorId() SBE_NOEXCEPT + { + return 1605; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingSystemVendorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingSystemVendorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradingSystemVendorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingSystemVendorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingSystemVendorSinceVersion(); + return m_actingVersion >= tradingSystemVendorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingSystemVendorEncodingOffset() SBE_NOEXCEPT { - return 92; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingSystemVendorEncodingOffset() SBE_NOEXCEPT + { + return 92; + } - static SBE_CONSTEXPR char tradingSystemVendorNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char tradingSystemVendorNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char tradingSystemVendorMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char tradingSystemVendorMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char tradingSystemVendorMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char tradingSystemVendorMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - tradingSystemVendorEncodingLength() SBE_NOEXCEPT { - return 10; - } + static SBE_CONSTEXPR std::size_t tradingSystemVendorEncodingLength() SBE_NOEXCEPT + { + return 10; + } - static SBE_CONSTEXPR std::uint64_t tradingSystemVendorLength() SBE_NOEXCEPT { - return 10; - } + static SBE_CONSTEXPR std::uint64_t tradingSystemVendorLength() SBE_NOEXCEPT + { + return 10; + } - SBE_NODISCARD const char *tradingSystemVendor() const SBE_NOEXCEPT { - return m_buffer + m_offset + 92; - } + SBE_NODISCARD const char *tradingSystemVendor() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 92; + } - SBE_NODISCARD char *tradingSystemVendor() SBE_NOEXCEPT { - return m_buffer + m_offset + 92; - } + SBE_NODISCARD char *tradingSystemVendor() SBE_NOEXCEPT + { + return m_buffer + m_offset + 92; + } - SBE_NODISCARD char tradingSystemVendor(const std::uint64_t index) const { - if (index >= 10) { - throw std::runtime_error( - "index out of range for tradingSystemVendor [E104]"); - } + SBE_NODISCARD char tradingSystemVendor(const std::uint64_t index) const + { + if (index >= 10) + { + throw std::runtime_error("index out of range for tradingSystemVendor [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 92 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 92 + (index * 1), sizeof(char)); + return (val); + } - Establish503 & - tradingSystemVendor(const std::uint64_t index, const char value) { - if (index >= 10) { - throw std::runtime_error( - "index out of range for tradingSystemVendor [E105]"); - } + Establish503 &tradingSystemVendor(const std::uint64_t index, const char value) + { + if (index >= 10) + { + throw std::runtime_error("index out of range for tradingSystemVendor [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 92 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 92 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getTradingSystemVendor(char *const dst, const std::uint64_t length) const { - if (length > 10) { - throw std::runtime_error( - "length too large for getTradingSystemVendor [E106]"); - } + std::uint64_t getTradingSystemVendor(char *const dst, const std::uint64_t length) const + { + if (length > 10) + { + throw std::runtime_error("length too large for getTradingSystemVendor [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 92, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 92, sizeof(char) * static_cast(length)); + return length; + } - Establish503 &putTradingSystemVendor(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 92, src, sizeof(char) * 10); - return *this; - } + Establish503 &putTradingSystemVendor(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 92, src, sizeof(char) * 10); + return *this; + } - SBE_NODISCARD std::string getTradingSystemVendorAsString() const { - const char *buffer = m_buffer + m_offset + 92; - size_t length = 0; + SBE_NODISCARD std::string getTradingSystemVendorAsString() const + { + const char *buffer = m_buffer + m_offset + 92; + std::size_t length = 0; - for (; length < 10 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 10 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTradingSystemVendorAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTradingSystemVendorAsString(); + std::string getTradingSystemVendorAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTradingSystemVendorAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getTradingSystemVendorAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 92; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTradingSystemVendorAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 92; + std::size_t length = 0; - for (; length < 10 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 10 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Establish503 &putTradingSystemVendor(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 10) { - throw std::runtime_error( - "string too large for putTradingSystemVendor [E106]"); - } + #if __cplusplus >= 201703L + Establish503 &putTradingSystemVendor(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 10) + { + throw std::runtime_error("string too large for putTradingSystemVendor [E106]"); + } - std::memcpy(m_buffer + m_offset + 92, str.data(), srcLength); - for (size_t start = srcLength; start < 10; ++start) { - m_buffer[m_offset + 92 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 92, str.data(), srcLength); + for (std::size_t start = srcLength; start < 10; ++start) + { + m_buffer[m_offset + 92 + start] = 0; + } - return *this; - } -#else - Establish503 &putTradingSystemVendor(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 10) { - throw std::runtime_error( - "string too large for putTradingSystemVendor [E106]"); - } + return *this; + } + #else + Establish503 &putTradingSystemVendor(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 10) + { + throw std::runtime_error("string too large for putTradingSystemVendor [E106]"); + } - std::memcpy(m_buffer + m_offset + 92, str.c_str(), srcLength); - for (size_t start = srcLength; start < 10; ++start) { - m_buffer[m_offset + 92 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 92, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 10; ++start) + { + m_buffer[m_offset + 92 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 102; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 102; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 102, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 102, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Establish503 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 102, &val, sizeof(std::uint64_t)); - return *this; - } + Establish503 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 102, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 110; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 110; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Establish503 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint64_t)); - return *this; - } + Establish503 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t nextSeqNoId() SBE_NOEXCEPT { - return 39013; - } + static SBE_CONSTEXPR std::uint16_t nextSeqNoId() SBE_NOEXCEPT + { + return 39013; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - nextSeqNoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t nextSeqNoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool nextSeqNoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool nextSeqNoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= nextSeqNoSinceVersion(); + return m_actingVersion >= nextSeqNoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - nextSeqNoEncodingOffset() SBE_NOEXCEPT { - return 118; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t nextSeqNoEncodingOffset() SBE_NOEXCEPT + { + return 118; + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t nextSeqNo() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 118, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t nextSeqNo() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 118, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - Establish503 &nextSeqNo(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 118, &val, sizeof(std::uint32_t)); - return *this; - } + Establish503 &nextSeqNo(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 118, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SessionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SessionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sessionId() SBE_NOEXCEPT { return 39006; } + static SBE_CONSTEXPR std::uint16_t sessionId() SBE_NOEXCEPT + { + return 39006; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sessionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sessionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sessionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sessionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sessionSinceVersion(); + return m_actingVersion >= sessionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sessionEncodingOffset() SBE_NOEXCEPT { - return 122; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sessionEncodingOffset() SBE_NOEXCEPT + { + return 122; + } - static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t sessionLength() SBE_NOEXCEPT { return 3; } + static SBE_CONSTEXPR std::uint64_t sessionLength() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD const char *session() const SBE_NOEXCEPT { - return m_buffer + m_offset + 122; - } + SBE_NODISCARD const char *session() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 122; + } - SBE_NODISCARD char *session() SBE_NOEXCEPT { - return m_buffer + m_offset + 122; - } + SBE_NODISCARD char *session() SBE_NOEXCEPT + { + return m_buffer + m_offset + 122; + } - SBE_NODISCARD char session(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error("index out of range for session [E104]"); - } + SBE_NODISCARD char session(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for session [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 122 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 122 + (index * 1), sizeof(char)); + return (val); + } - Establish503 &session(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error("index out of range for session [E105]"); - } + Establish503 &session(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for session [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 122 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 122 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getSession(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error("length too large for getSession [E106]"); - } + std::uint64_t getSession(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getSession [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 122, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 122, sizeof(char) * static_cast(length)); + return length; + } - Establish503 &putSession(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 122, src, sizeof(char) * 3); - return *this; - } + Establish503 &putSession(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 122, src, sizeof(char) * 3); + return *this; + } - Establish503 &putSession( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 122, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 123, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 124, &val2, sizeof(char)); + Establish503 &putSession( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 122, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 123, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 124, &val2, sizeof(char)); - return *this; - } + return *this; + } - SBE_NODISCARD std::string getSessionAsString() const { - const char *buffer = m_buffer + m_offset + 122; - size_t length = 0; + SBE_NODISCARD std::string getSessionAsString() const + { + const char *buffer = m_buffer + m_offset + 122; + std::size_t length = 0; - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSessionAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSessionAsString(); + std::string getSessionAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSessionAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 122; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 122; + std::size_t length = 0; - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Establish503 &putSession(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putSession [E106]"); - } + #if __cplusplus >= 201703L + Establish503 &putSession(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSession [E106]"); + } - std::memcpy(m_buffer + m_offset + 122, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 122 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 122, str.data(), srcLength); + for (std::size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 122 + start] = 0; + } - return *this; - } -#else - Establish503 &putSession(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putSession [E106]"); - } + return *this; + } + #else + Establish503 &putSession(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSession [E106]"); + } - std::memcpy(m_buffer + m_offset + 122, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 122 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 122, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 122 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - FirmMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FirmMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t firmId() SBE_NOEXCEPT { return 39007; } + static SBE_CONSTEXPR std::uint16_t firmId() SBE_NOEXCEPT + { + return 39007; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - firmSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t firmSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool firmInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool firmInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= firmSinceVersion(); + return m_actingVersion >= firmSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - firmEncodingOffset() SBE_NOEXCEPT { - return 125; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t firmEncodingOffset() SBE_NOEXCEPT + { + return 125; + } - static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t firmLength() SBE_NOEXCEPT { return 5; } + static SBE_CONSTEXPR std::uint64_t firmLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *firm() const SBE_NOEXCEPT { - return m_buffer + m_offset + 125; - } + SBE_NODISCARD const char *firm() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 125; + } - SBE_NODISCARD char *firm() SBE_NOEXCEPT { return m_buffer + m_offset + 125; } + SBE_NODISCARD char *firm() SBE_NOEXCEPT + { + return m_buffer + m_offset + 125; + } - SBE_NODISCARD char firm(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for firm [E104]"); - } + SBE_NODISCARD char firm(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for firm [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 125 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 125 + (index * 1), sizeof(char)); + return (val); + } - Establish503 &firm(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for firm [E105]"); - } + Establish503 &firm(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for firm [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 125 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 125 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getFirm(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getFirm [E106]"); - } + std::uint64_t getFirm(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getFirm [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 125, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 125, sizeof(char) * static_cast(length)); + return length; + } - Establish503 &putFirm(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 125, src, sizeof(char) * 5); - return *this; - } + Establish503 &putFirm(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 125, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getFirmAsString() const { - const char *buffer = m_buffer + m_offset + 125; - size_t length = 0; + SBE_NODISCARD std::string getFirmAsString() const + { + const char *buffer = m_buffer + m_offset + 125; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getFirmAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getFirmAsString(); + std::string getFirmAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getFirmAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 125; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 125; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Establish503 &putFirm(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putFirm [E106]"); - } + #if __cplusplus >= 201703L + Establish503 &putFirm(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putFirm [E106]"); + } - std::memcpy(m_buffer + m_offset + 125, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 125 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 125, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 125 + start] = 0; + } - return *this; - } -#else - Establish503 &putFirm(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putFirm [E106]"); - } + return *this; + } + #else + Establish503 &putFirm(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putFirm [E106]"); + } - std::memcpy(m_buffer + m_offset + 125, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 125 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 125, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 125 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *KeepAliveIntervalMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *KeepAliveIntervalMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t keepAliveIntervalId() SBE_NOEXCEPT { - return 39014; - } + static SBE_CONSTEXPR std::uint16_t keepAliveIntervalId() SBE_NOEXCEPT + { + return 39014; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - keepAliveIntervalSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t keepAliveIntervalSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool keepAliveIntervalInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool keepAliveIntervalInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= keepAliveIntervalSinceVersion(); + return m_actingVersion >= keepAliveIntervalSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - keepAliveIntervalEncodingOffset() SBE_NOEXCEPT { - return 130; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t keepAliveIntervalEncodingOffset() SBE_NOEXCEPT + { + return 130; + } - static SBE_CONSTEXPR std::uint16_t - keepAliveIntervalNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t keepAliveIntervalNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - keepAliveIntervalEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t keepAliveIntervalEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t keepAliveInterval() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 130, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t keepAliveInterval() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 130, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - Establish503 &keepAliveInterval(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 130, &val, sizeof(std::uint16_t)); - return *this; - } + Establish503 &keepAliveInterval(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 130, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "data"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "data"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static const char *credentialsCharacterEncoding() SBE_NOEXCEPT { - return "US-ASCII"; - } + static const char *credentialsCharacterEncoding() SBE_NOEXCEPT + { + return "US-ASCII"; + } - static SBE_CONSTEXPR std::uint64_t credentialsSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t credentialsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - bool credentialsInActingVersion() SBE_NOEXCEPT { + bool credentialsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= credentialsSinceVersion(); + return m_actingVersion >= credentialsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - static SBE_CONSTEXPR std::uint16_t credentialsId() SBE_NOEXCEPT { - return 39008; - } + static SBE_CONSTEXPR std::uint16_t credentialsId() SBE_NOEXCEPT + { + return 39008; + } - static SBE_CONSTEXPR std::uint64_t credentialsHeaderLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t credentialsHeaderLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t credentialsLength() const { - std::uint16_t length; - std::memcpy(&length, m_buffer + sbePosition(), sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(length); - } + SBE_NODISCARD std::uint16_t credentialsLength() const + { + std::uint16_t length; + std::memcpy(&length, m_buffer + sbePosition(), sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(length); + } - std::uint64_t skipCredentials() { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - sbePosition(lengthPosition + lengthOfLengthField + dataLength); - return dataLength; - } + std::uint64_t skipCredentials() + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + sbePosition(lengthPosition + lengthOfLengthField + dataLength); + return dataLength; + } - SBE_NODISCARD const char *credentials() { - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + sbePosition(), sizeof(std::uint16_t)); - const char *fieldPtr = m_buffer + sbePosition() + 2; - sbePosition( - sbePosition() + 2 + SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue)); - return fieldPtr; - } + SBE_NODISCARD const char *credentials() + { + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + sbePosition(), sizeof(std::uint16_t)); + const char *fieldPtr = m_buffer + sbePosition() + 2; + sbePosition(sbePosition() + 2 + SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue)); + return fieldPtr; + } - std::uint64_t getCredentials(char *dst, const std::uint64_t length) { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - sbePosition(lengthPosition + lengthOfLengthField); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - std::uint64_t bytesToCopy = length < dataLength ? length : dataLength; - std::uint64_t pos = sbePosition(); - sbePosition(pos + dataLength); - std::memcpy(dst, m_buffer + pos, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::uint64_t getCredentials(char *dst, const std::uint64_t length) + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + sbePosition(lengthPosition + lengthOfLengthField); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + std::uint64_t bytesToCopy = length < dataLength ? length : dataLength; + std::uint64_t pos = sbePosition(); + sbePosition(pos + dataLength); + std::memcpy(dst, m_buffer + pos, static_cast(bytesToCopy)); + return bytesToCopy; + } - Establish503 &putCredentials(const char *src, const std::uint16_t length) { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - std::uint16_t lengthFieldValue = SBE_LITTLE_ENDIAN_ENCODE_16(length); - sbePosition(lengthPosition + lengthOfLengthField); - std::memcpy( - m_buffer + lengthPosition, &lengthFieldValue, sizeof(std::uint16_t)); - if (length != std::uint16_t(0)) { - std::uint64_t pos = sbePosition(); - sbePosition(pos + length); - std::memcpy(m_buffer + pos, src, length); - } - return *this; - } + Establish503 &putCredentials(const char *src, const std::uint16_t length) + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + std::uint16_t lengthFieldValue = SBE_LITTLE_ENDIAN_ENCODE_16(length); + sbePosition(lengthPosition + lengthOfLengthField); + std::memcpy(m_buffer + lengthPosition, &lengthFieldValue, sizeof(std::uint16_t)); + if (length != std::uint16_t(0)) + { + std::uint64_t pos = sbePosition(); + sbePosition(pos + length); + std::memcpy(m_buffer + pos, src, length); + } + return *this; + } - std::string getCredentialsAsString() { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - sbePosition(lengthPosition + lengthOfLengthField); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - std::uint64_t pos = sbePosition(); - const std::string result(m_buffer + pos, dataLength); - sbePosition(pos + dataLength); - return result; - } + std::string getCredentialsAsString() + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + sbePosition(lengthPosition + lengthOfLengthField); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + std::uint64_t pos = sbePosition(); + const std::string result(m_buffer + pos, dataLength); + sbePosition(pos + dataLength); + return result; + } - std::string getCredentialsAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCredentialsAsString(); + std::string getCredentialsAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCredentialsAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - std::string_view getCredentialsAsStringView() { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - sbePosition(lengthPosition + lengthOfLengthField); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - std::uint64_t pos = sbePosition(); - const std::string_view result(m_buffer + pos, dataLength); - sbePosition(pos + dataLength); - return result; - } -#endif + #if __cplusplus >= 201703L + std::string_view getCredentialsAsStringView() + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + sbePosition(lengthPosition + lengthOfLengthField); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + std::uint64_t pos = sbePosition(); + const std::string_view result(m_buffer + pos, dataLength); + sbePosition(pos + dataLength); + return result; + } + #endif - Establish503 &putCredentials(const std::string &str) { - if (str.length() > 65534) { - throw std::runtime_error( - "std::string too long for length type [E109]"); - } - return putCredentials( - str.data(), static_cast(str.length())); - } + Establish503 &putCredentials(const std::string &str) + { + if (str.length() > 65534) + { + throw std::runtime_error("std::string too long for length type [E109]"); + } + return putCredentials(str.data(), static_cast(str.length())); + } -#if __cplusplus >= 201703L - Establish503 &putCredentials(const std::string_view str) { - if (str.length() > 65534) { - throw std::runtime_error( - "std::string too long for length type [E109]"); - } - return putCredentials( - str.data(), static_cast(str.length())); - } -#endif + #if __cplusplus >= 201703L + Establish503 &putCredentials(const std::string_view str) + { + if (str.length() > 65534) + { + throw std::runtime_error("std::string too long for length type [E109]"); + } + return putCredentials(str.data(), static_cast(str.length())); + } + #endif - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, Establish503 _writer) { - Establish503 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "Establish503", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, Establish503 _writer) +{ + Establish503 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("HMACSignature": )"; - builder << '"' << writer.getHMACSignatureAsJsonEscapedString().c_str() - << '"'; + builder << '{'; + builder << R"("Name": "Establish503", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("AccessKeyID": )"; - builder << '"' << writer.getAccessKeyIDAsJsonEscapedString().c_str() - << '"'; + builder << R"("HMACSignature": )"; + builder << '"' << + writer.getHMACSignatureAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("TradingSystemName": )"; - builder << '"' << writer.getTradingSystemNameAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("AccessKeyID": )"; + builder << '"' << + writer.getAccessKeyIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("TradingSystemVersion": )"; - builder << '"' - << writer.getTradingSystemVersionAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("TradingSystemName": )"; + builder << '"' << + writer.getTradingSystemNameAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("TradingSystemVendor": )"; - builder << '"' - << writer.getTradingSystemVendorAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("TradingSystemVersion": )"; + builder << '"' << + writer.getTradingSystemVersionAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << ", "; + builder << R"("TradingSystemVendor": )"; + builder << '"' << + writer.getTradingSystemVendorAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("NextSeqNo": )"; - builder << +writer.nextSeqNo(); + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << ", "; - builder << R"("Session": )"; - builder << '"' << writer.getSessionAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("NextSeqNo": )"; + builder << +writer.nextSeqNo(); - builder << ", "; - builder << R"("Firm": )"; - builder << '"' << writer.getFirmAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Session": )"; + builder << '"' << + writer.getSessionAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("KeepAliveInterval": )"; - builder << +writer.keepAliveInterval(); + builder << ", "; + builder << R"("Firm": )"; + builder << '"' << + writer.getFirmAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("Credentials": )"; - builder << '"' << writer.getCredentialsAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("KeepAliveInterval": )"; + builder << +writer.keepAliveInterval(); - builder << '}'; + builder << ", "; + builder << R"("Credentials": )"; + builder << '"' << + writer.getCredentialsAsJsonEscapedString().c_str() << '"'; - return builder; - } + builder << '}'; - void skip() { skipCredentials(); } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } +void skip() +{ + skipCredentials(); +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t CredentialsLength = 0) { +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t credentialsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += credentialsHeaderLength(); - if (CredentialsLength > 65534) { - throw std::runtime_error( - "CredentialsLength too long for length type [E109]"); - } - length += CredentialsLength; - return length; + length += credentialsHeaderLength(); + if (credentialsLength > 65534LL) + { + throw std::runtime_error("credentialsLength too long for length type [E109]"); + } + length += credentialsLength; + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/EstablishmentAck504.h b/src/lib/orderman/ilink3/generated/EstablishmentAck504.h index 7e5c52240..9e319239b 100644 --- a/src/lib/orderman/ilink3/generated/EstablishmentAck504.h +++ b/src/lib/orderman/ilink3/generated/EstablishmentAck504.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,866 +86,967 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class EstablishmentAck504 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class EstablishmentAck504 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(38); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(504); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - EstablishmentAck504() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - EstablishmentAck504( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - EstablishmentAck504(char *buffer, const std::uint64_t bufferLength) - : EstablishmentAck504( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + EstablishmentAck504() = default; - EstablishmentAck504( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : EstablishmentAck504( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + EstablishmentAck504( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)38; - } + EstablishmentAck504(char *buffer, const std::uint64_t bufferLength) : + EstablishmentAck504(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + EstablishmentAck504( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + EstablishmentAck504(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)504; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(38); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(504); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "EstablishmentAck"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - EstablishmentAck504 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = EstablishmentAck504( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "EstablishmentAck"; + } - EstablishmentAck504 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + EstablishmentAck504 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = EstablishmentAck504(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = EstablishmentAck504( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + EstablishmentAck504 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - EstablishmentAck504 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = EstablishmentAck504( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = EstablishmentAck504( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + EstablishmentAck504 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = EstablishmentAck504(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + EstablishmentAck504 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - EstablishmentAck504 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + EstablishmentAck504 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - EstablishmentAck504 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + EstablishmentAck504 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - EstablishmentAck504 & - requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + EstablishmentAck504 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t nextSeqNoId() SBE_NOEXCEPT { - return 39013; - } + static SBE_CONSTEXPR std::uint16_t nextSeqNoId() SBE_NOEXCEPT + { + return 39013; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - nextSeqNoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t nextSeqNoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool nextSeqNoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool nextSeqNoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= nextSeqNoSinceVersion(); + return m_actingVersion >= nextSeqNoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - nextSeqNoEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t nextSeqNoEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t nextSeqNo() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t nextSeqNo() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - EstablishmentAck504 &nextSeqNo(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint32_t)); - return *this; - } + EstablishmentAck504 &nextSeqNo(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - PreviousSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PreviousSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t previousSeqNoId() SBE_NOEXCEPT { - return 39021; - } + static SBE_CONSTEXPR std::uint16_t previousSeqNoId() SBE_NOEXCEPT + { + return 39021; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - previousSeqNoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t previousSeqNoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool previousSeqNoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool previousSeqNoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= previousSeqNoSinceVersion(); + return m_actingVersion >= previousSeqNoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - previousSeqNoEncodingOffset() SBE_NOEXCEPT { - return 20; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t previousSeqNoEncodingOffset() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint32_t previousSeqNoNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t previousSeqNoNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t previousSeqNo() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t previousSeqNo() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - EstablishmentAck504 &previousSeqNo(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint32_t)); - return *this; - } + EstablishmentAck504 &previousSeqNo(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - PreviousUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PreviousUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t previousUUIDId() SBE_NOEXCEPT { - return 39015; - } + static SBE_CONSTEXPR std::uint16_t previousUUIDId() SBE_NOEXCEPT + { + return 39015; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - previousUUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t previousUUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool previousUUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool previousUUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= previousUUIDSinceVersion(); + return m_actingVersion >= previousUUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - previousUUIDEncodingOffset() SBE_NOEXCEPT { - return 24; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t previousUUIDEncodingOffset() SBE_NOEXCEPT + { + return 24; + } - static SBE_CONSTEXPR std::uint64_t previousUUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t previousUUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t previousUUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t previousUUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - EstablishmentAck504 &previousUUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint64_t)); - return *this; - } + EstablishmentAck504 &previousUUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *KeepAliveIntervalMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *KeepAliveIntervalMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t keepAliveIntervalId() SBE_NOEXCEPT { - return 39014; - } + static SBE_CONSTEXPR std::uint16_t keepAliveIntervalId() SBE_NOEXCEPT + { + return 39014; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - keepAliveIntervalSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t keepAliveIntervalSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool keepAliveIntervalInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool keepAliveIntervalInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= keepAliveIntervalSinceVersion(); + return m_actingVersion >= keepAliveIntervalSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - keepAliveIntervalEncodingOffset() SBE_NOEXCEPT { - return 32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t keepAliveIntervalEncodingOffset() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR std::uint16_t - keepAliveIntervalNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t keepAliveIntervalNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t keepAliveIntervalMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - keepAliveIntervalEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t keepAliveIntervalEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t keepAliveInterval() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t keepAliveInterval() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - EstablishmentAck504 & - keepAliveInterval(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::uint16_t)); - return *this; - } + EstablishmentAck504 &keepAliveInterval(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *SecretKeySecureIDExpirationMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecretKeySecureIDExpirationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t - secretKeySecureIDExpirationId() SBE_NOEXCEPT { - return 39022; - } + static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationId() SBE_NOEXCEPT + { + return 39022; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - secretKeySecureIDExpirationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t secretKeySecureIDExpirationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool - secretKeySecureIDExpirationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool secretKeySecureIDExpirationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= secretKeySecureIDExpirationSinceVersion(); + return m_actingVersion >= secretKeySecureIDExpirationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - secretKeySecureIDExpirationEncodingOffset() SBE_NOEXCEPT { - return 34; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t secretKeySecureIDExpirationEncodingOffset() SBE_NOEXCEPT + { + return 34; + } - static SBE_CONSTEXPR std::uint16_t - secretKeySecureIDExpirationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t - secretKeySecureIDExpirationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t - secretKeySecureIDExpirationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - secretKeySecureIDExpirationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t secretKeySecureIDExpirationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t - secretKeySecureIDExpiration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 34, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t secretKeySecureIDExpiration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 34, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - EstablishmentAck504 & - secretKeySecureIDExpiration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 34, &val, sizeof(std::uint16_t)); - return *this; - } + EstablishmentAck504 &secretKeySecureIDExpiration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 34, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT { - return 39010; - } + static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT + { + return 39010; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= faultToleranceIndicatorSinceVersion(); + return m_actingVersion >= faultToleranceIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT { - return 36; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 36; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD FTI::Value faultToleranceIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint8_t)); - return FTI::get((val)); - } + SBE_NODISCARD std::uint8_t faultToleranceIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint8_t)); + return (val); + } - EstablishmentAck504 & - faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 36, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD FTI::Value faultToleranceIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint8_t)); + return FTI::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + EstablishmentAck504 &faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 36, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 37; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 37, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 37, sizeof(std::uint8_t)); + return (val); + } - EstablishmentAck504 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 37, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 37, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - EstablishmentAck504 _writer) { - EstablishmentAck504 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "EstablishmentAck504", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + EstablishmentAck504 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 37, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("UUID": )"; - builder << +writer.uUID(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, EstablishmentAck504 _writer) +{ + EstablishmentAck504 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << '{'; + builder << R"("Name": "EstablishmentAck504", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("NextSeqNo": )"; - builder << +writer.nextSeqNo(); + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("PreviousSeqNo": )"; - builder << +writer.previousSeqNo(); + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << ", "; - builder << R"("PreviousUUID": )"; - builder << +writer.previousUUID(); + builder << ", "; + builder << R"("NextSeqNo": )"; + builder << +writer.nextSeqNo(); - builder << ", "; - builder << R"("KeepAliveInterval": )"; - builder << +writer.keepAliveInterval(); + builder << ", "; + builder << R"("PreviousSeqNo": )"; + builder << +writer.previousSeqNo(); - builder << ", "; - builder << R"("SecretKeySecureIDExpiration": )"; - builder << +writer.secretKeySecureIDExpiration(); + builder << ", "; + builder << R"("PreviousUUID": )"; + builder << +writer.previousUUID(); - builder << ", "; - builder << R"("FaultToleranceIndicator": )"; - builder << '"' << writer.faultToleranceIndicator() << '"'; + builder << ", "; + builder << R"("KeepAliveInterval": )"; + builder << +writer.keepAliveInterval(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("SecretKeySecureIDExpiration": )"; + builder << +writer.secretKeySecureIDExpiration(); - builder << '}'; + builder << ", "; + builder << R"("FaultToleranceIndicator": )"; + builder << '"' << writer.faultToleranceIndicator() << '"'; - return builder; - } + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - void skip() {} + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/EstablishmentReject505.h b/src/lib/orderman/ilink3/generated/EstablishmentReject505.h index 72140a199..5b81b904f 100644 --- a/src/lib/orderman/ilink3/generated/EstablishmentReject505.h +++ b/src/lib/orderman/ilink3/generated/EstablishmentReject505.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,836 +86,953 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class EstablishmentReject505 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class EstablishmentReject505 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(72); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(505); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - EstablishmentReject505() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - EstablishmentReject505( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - EstablishmentReject505(char *buffer, const std::uint64_t bufferLength) - : EstablishmentReject505( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + EstablishmentReject505() = default; - EstablishmentReject505( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : EstablishmentReject505( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + EstablishmentReject505( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)72; - } + EstablishmentReject505(char *buffer, const std::uint64_t bufferLength) : + EstablishmentReject505(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + EstablishmentReject505( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + EstablishmentReject505(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)505; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(72); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(505); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "EstablishmentReject"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - EstablishmentReject505 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = EstablishmentReject505( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "EstablishmentReject"; + } - EstablishmentReject505 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + EstablishmentReject505 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = EstablishmentReject505(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = EstablishmentReject505( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + EstablishmentReject505 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - EstablishmentReject505 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = EstablishmentReject505( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = EstablishmentReject505( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + EstablishmentReject505 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = EstablishmentReject505(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + EstablishmentReject505 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - EstablishmentReject505 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + EstablishmentReject505 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t reasonId() SBE_NOEXCEPT { return 39011; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - reasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool reasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t reasonId() SBE_NOEXCEPT + { + return 39011; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool reasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= reasonSinceVersion(); + return m_actingVersion >= reasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - reasonEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reasonEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT { - return 48; - } + static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t reasonLength() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint64_t reasonLength() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD const char *reason() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } + SBE_NODISCARD const char *reason() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char *reason() SBE_NOEXCEPT { return m_buffer + m_offset + 0; } + SBE_NODISCARD char *reason() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char reason(const std::uint64_t index) const { - if (index >= 48) { - throw std::runtime_error("index out of range for reason [E104]"); - } + SBE_NODISCARD char reason(const std::uint64_t index) const + { + if (index >= 48) + { + throw std::runtime_error("index out of range for reason [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - EstablishmentReject505 &reason(const std::uint64_t index, const char value) { - if (index >= 48) { - throw std::runtime_error("index out of range for reason [E105]"); - } + EstablishmentReject505 &reason(const std::uint64_t index, const char value) + { + if (index >= 48) + { + throw std::runtime_error("index out of range for reason [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getReason(char *const dst, const std::uint64_t length) const { - if (length > 48) { - throw std::runtime_error("length too large for getReason [E106]"); - } + std::uint64_t getReason(char *const dst, const std::uint64_t length) const + { + if (length > 48) + { + throw std::runtime_error("length too large for getReason [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - EstablishmentReject505 &putReason(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 48); - return *this; - } + EstablishmentReject505 &putReason(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 48); + return *this; + } - SBE_NODISCARD std::string getReasonAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + SBE_NODISCARD std::string getReasonAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 48 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 48 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getReasonAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getReasonAsString(); + std::string getReasonAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getReasonAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 48 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 48 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - EstablishmentReject505 &putReason(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 48) { - throw std::runtime_error("string too large for putReason [E106]"); - } + #if __cplusplus >= 201703L + EstablishmentReject505 &putReason(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 48) + { + throw std::runtime_error("string too large for putReason [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 48; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 48; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#else - EstablishmentReject505 &putReason(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 48) { - throw std::runtime_error("string too large for putReason [E106]"); - } + return *this; + } + #else + EstablishmentReject505 &putReason(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 48) + { + throw std::runtime_error("string too large for putReason [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 48; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 48; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 48; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - EstablishmentReject505 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); - return *this; - } + EstablishmentReject505 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 56; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 56; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - EstablishmentReject505 & - requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); - return *this; - } + EstablishmentReject505 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t nextSeqNoId() SBE_NOEXCEPT { - return 39013; - } + static SBE_CONSTEXPR std::uint16_t nextSeqNoId() SBE_NOEXCEPT + { + return 39013; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - nextSeqNoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t nextSeqNoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool nextSeqNoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool nextSeqNoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= nextSeqNoSinceVersion(); + return m_actingVersion >= nextSeqNoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - nextSeqNoEncodingOffset() SBE_NOEXCEPT { - return 64; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t nextSeqNoEncodingOffset() SBE_NOEXCEPT + { + return 64; + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t nextSeqNo() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t nextSeqNo() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - EstablishmentReject505 &nextSeqNo(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint32_t)); - return *this; - } + EstablishmentReject505 &nextSeqNo(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t errorCodesId() SBE_NOEXCEPT { - return 39012; - } + static SBE_CONSTEXPR std::uint16_t errorCodesId() SBE_NOEXCEPT + { + return 39012; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - errorCodesSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t errorCodesSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool errorCodesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool errorCodesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= errorCodesSinceVersion(); + return m_actingVersion >= errorCodesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - errorCodesEncodingOffset() SBE_NOEXCEPT { - return 68; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t errorCodesEncodingOffset() SBE_NOEXCEPT + { + return 68; + } - static SBE_CONSTEXPR std::uint16_t errorCodesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t errorCodesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t errorCodes() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 68, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t errorCodes() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 68, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - EstablishmentReject505 &errorCodes(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 68, &val, sizeof(std::uint16_t)); - return *this; - } + EstablishmentReject505 &errorCodes(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 68, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT { - return 39010; - } + static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT + { + return 39010; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= faultToleranceIndicatorSinceVersion(); + return m_actingVersion >= faultToleranceIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT { - return 70; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 70; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD FTI::Value faultToleranceIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t)); - return FTI::get((val)); - } + SBE_NODISCARD std::uint8_t faultToleranceIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t)); + return (val); + } - EstablishmentReject505 & - faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 70, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD FTI::Value faultToleranceIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t)); + return FTI::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + EstablishmentReject505 &faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 70, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 71; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); + return (val); + } - EstablishmentReject505 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 71, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - EstablishmentReject505 _writer) { - EstablishmentReject505 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "EstablishmentReject505", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + EstablishmentReject505 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 71, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("Reason": )"; - builder << '"' << writer.getReasonAsJsonEscapedString().c_str() << '"'; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, EstablishmentReject505 _writer) +{ + EstablishmentReject505 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << '{'; + builder << R"("Name": "EstablishmentReject505", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << R"("Reason": )"; + builder << '"' << + writer.getReasonAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("NextSeqNo": )"; - builder << +writer.nextSeqNo(); + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("ErrorCodes": )"; - builder << +writer.errorCodes(); + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << ", "; - builder << R"("FaultToleranceIndicator": )"; - builder << '"' << writer.faultToleranceIndicator() << '"'; + builder << ", "; + builder << R"("NextSeqNo": )"; + builder << +writer.nextSeqNo(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("ErrorCodes": )"; + builder << +writer.errorCodes(); - builder << '}'; + builder << ", "; + builder << R"("FaultToleranceIndicator": )"; + builder << '"' << writer.faultToleranceIndicator() << '"'; - return builder; - } + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - void skip() {} + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecAckStatus.h b/src/lib/orderman/ilink3/generated/ExecAckStatus.h index e06576d63..f9506386d 100644 --- a/src/lib/orderman/ilink3/generated/ExecAckStatus.h +++ b/src/lib/orderman/ilink3/generated/ExecAckStatus.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_EXECACKSTATUS_H_ #define _ILINKBINARY_EXECACKSTATUS_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class ExecAckStatus { - public: - enum Value { - Accepted = (std::uint8_t)1, - Rejected = (std::uint8_t)2, - NULL_VALUE = (std::uint8_t)255 - }; +class ExecAckStatus +{ +public: + enum Value + { + Accepted = static_cast(1), + Rejected = static_cast(2), + NULL_VALUE = static_cast(255) + }; - static ExecAckStatus::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return Accepted; - case 2: - return Rejected; - case 255: - return NULL_VALUE; - } + static ExecAckStatus::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return Accepted; + case static_cast(2): return Rejected; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ExecAckStatus [E103]"); - } + throw std::runtime_error("unknown value for enum ExecAckStatus [E103]"); + } - static const char *c_str(const ExecAckStatus::Value value) { - switch (value) { - case Accepted: - return "Accepted"; - case Rejected: - return "Rejected"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ExecAckStatus::Value value) + { + switch (value) + { + case Accepted: return "Accepted"; + case Rejected: return "Rejected"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum ExecAckStatus [E103]:"); - } + throw std::runtime_error("unknown value for enum ExecAckStatus [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ExecAckStatus::Value m) { - return os << ExecAckStatus::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ExecAckStatus::Value m) + { + return os << ExecAckStatus::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecInst.h b/src/lib/orderman/ilink3/generated/ExecInst.h index b58da3bf1..e1595c161 100644 --- a/src/lib/orderman/ilink3/generated/ExecInst.h +++ b/src/lib/orderman/ilink3/generated/ExecInst.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,364 +86,428 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace iLinkBinary { -class ExecInst { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class ExecInst +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - ExecInst() = default; + ExecInst() = default; - ExecInst( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_actingVersion(actingVersion) { - if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 1) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + ExecInst( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_actingVersion(actingVersion) + { + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 1) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - ExecInst( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : ExecInst(buffer, 0, bufferLength, actingVersion) {} + ExecInst( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + ExecInst(buffer, 0, bufferLength, actingVersion) + { + } - ExecInst(char *buffer, const std::uint64_t bufferLength) - : ExecInst(buffer, 0, bufferLength, sbeSchemaVersion()) {} + ExecInst( + char *buffer, + const std::uint64_t bufferLength) : + ExecInst(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - ExecInst &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecInst(buffer, offset, bufferLength, actingVersion); - } + ExecInst &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecInst(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - ExecInst &clear() { - std::uint8_t zero = 0; - std::memcpy(m_buffer + m_offset, &zero, sizeof(std::uint8_t)); - return *this; - } + ExecInst &clear() + { + std::uint8_t zero = 0; + std::memcpy(m_buffer + m_offset, &zero, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD bool isEmpty() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return 0 == val; - } + SBE_NODISCARD bool isEmpty() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return 0 == val; + } - SBE_NODISCARD std::uint8_t rawValue() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return val; - } + SBE_NODISCARD std::uint8_t rawValue() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return val; + } - ExecInst &rawValue(std::uint8_t value) { - std::memcpy(m_buffer + m_offset, &value, sizeof(std::uint8_t)); - return *this; - } + ExecInst &rawValue(std::uint8_t value) + { + std::memcpy(m_buffer + m_offset, &value, sizeof(std::uint8_t)); + return *this; + } - static bool aON(const std::uint8_t bits) { return (bits & (1u << 0u)) != 0; } + static bool aON(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 0u)) != 0; + } - static std::uint8_t aON(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 0u)) - : static_cast(bits & ~(1u << 0u)); - } + static std::uint8_t aON(const std::uint8_t bits, const bool value) + { + return value ? static_cast(bits | (static_cast(1) << 0u)) : static_cast(bits & ~(static_cast(1) << 0u)); + } - SBE_NODISCARD bool aON() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 0u)) != 0; - } + SBE_NODISCARD bool aON() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 0u)) != 0; + } - ExecInst &aON(const bool value) { - std::uint8_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); - bits = - (value ? static_cast((bits) | (1u << 0u)) - : static_cast((bits) & ~(1u << 0u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); - return *this; - } + ExecInst &aON(const bool value) + { + std::uint8_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); + bits = (value ? static_cast((bits) | (static_cast(1) << 0u)) : static_cast((bits) & ~(static_cast(1) << 0u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); + return *this; + } - static bool oB(const std::uint8_t bits) { return (bits & (1u << 1u)) != 0; } + static bool oB(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 1u)) != 0; + } - static std::uint8_t oB(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 1u)) - : static_cast(bits & ~(1u << 1u)); - } + static std::uint8_t oB(const std::uint8_t bits, const bool value) + { + return value ? static_cast(bits | (static_cast(1) << 1u)) : static_cast(bits & ~(static_cast(1) << 1u)); + } - SBE_NODISCARD bool oB() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 1u)) != 0; - } + SBE_NODISCARD bool oB() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 1u)) != 0; + } - ExecInst &oB(const bool value) { - std::uint8_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); - bits = - (value ? static_cast((bits) | (1u << 1u)) - : static_cast((bits) & ~(1u << 1u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); - return *this; - } + ExecInst &oB(const bool value) + { + std::uint8_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); + bits = (value ? static_cast((bits) | (static_cast(1) << 1u)) : static_cast((bits) & ~(static_cast(1) << 1u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); + return *this; + } - static bool nH(const std::uint8_t bits) { return (bits & (1u << 2u)) != 0; } + static bool nH(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 2u)) != 0; + } - static std::uint8_t nH(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 2u)) - : static_cast(bits & ~(1u << 2u)); - } + static std::uint8_t nH(const std::uint8_t bits, const bool value) + { + return value ? static_cast(bits | (static_cast(1) << 2u)) : static_cast(bits & ~(static_cast(1) << 2u)); + } - SBE_NODISCARD bool nH() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 2u)) != 0; - } + SBE_NODISCARD bool nH() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 2u)) != 0; + } - ExecInst &nH(const bool value) { - std::uint8_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); - bits = - (value ? static_cast((bits) | (1u << 2u)) - : static_cast((bits) & ~(1u << 2u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); - return *this; - } + ExecInst &nH(const bool value) + { + std::uint8_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); + bits = (value ? static_cast((bits) | (static_cast(1) << 2u)) : static_cast((bits) & ~(static_cast(1) << 2u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); + return *this; + } - static bool reserved1(const std::uint8_t bits) { - return (bits & (1u << 3u)) != 0; - } + static bool reserved1(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 3u)) != 0; + } - static std::uint8_t reserved1(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 3u)) - : static_cast(bits & ~(1u << 3u)); - } + static std::uint8_t reserved1(const std::uint8_t bits, const bool value) + { + return value ? static_cast(bits | (static_cast(1) << 3u)) : static_cast(bits & ~(static_cast(1) << 3u)); + } - SBE_NODISCARD bool reserved1() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 3u)) != 0; - } + SBE_NODISCARD bool reserved1() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 3u)) != 0; + } - ExecInst &reserved1(const bool value) { - std::uint8_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); - bits = - (value ? static_cast((bits) | (1u << 3u)) - : static_cast((bits) & ~(1u << 3u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); - return *this; - } + ExecInst &reserved1(const bool value) + { + std::uint8_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); + bits = (value ? static_cast((bits) | (static_cast(1) << 3u)) : static_cast((bits) & ~(static_cast(1) << 3u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); + return *this; + } - static bool reserved2(const std::uint8_t bits) { - return (bits & (1u << 4u)) != 0; - } + static bool reserved2(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 4u)) != 0; + } - static std::uint8_t reserved2(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 4u)) - : static_cast(bits & ~(1u << 4u)); - } + static std::uint8_t reserved2(const std::uint8_t bits, const bool value) + { + return value ? static_cast(bits | (static_cast(1) << 4u)) : static_cast(bits & ~(static_cast(1) << 4u)); + } - SBE_NODISCARD bool reserved2() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 4u)) != 0; - } + SBE_NODISCARD bool reserved2() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 4u)) != 0; + } - ExecInst &reserved2(const bool value) { - std::uint8_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); - bits = - (value ? static_cast((bits) | (1u << 4u)) - : static_cast((bits) & ~(1u << 4u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); - return *this; - } + ExecInst &reserved2(const bool value) + { + std::uint8_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); + bits = (value ? static_cast((bits) | (static_cast(1) << 4u)) : static_cast((bits) & ~(static_cast(1) << 4u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); + return *this; + } - static bool reserved3(const std::uint8_t bits) { - return (bits & (1u << 5u)) != 0; - } + static bool reserved3(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 5u)) != 0; + } - static std::uint8_t reserved3(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 5u)) - : static_cast(bits & ~(1u << 5u)); - } + static std::uint8_t reserved3(const std::uint8_t bits, const bool value) + { + return value ? static_cast(bits | (static_cast(1) << 5u)) : static_cast(bits & ~(static_cast(1) << 5u)); + } - SBE_NODISCARD bool reserved3() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 5u)) != 0; - } + SBE_NODISCARD bool reserved3() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 5u)) != 0; + } - ExecInst &reserved3(const bool value) { - std::uint8_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); - bits = - (value ? static_cast((bits) | (1u << 5u)) - : static_cast((bits) & ~(1u << 5u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); - return *this; - } + ExecInst &reserved3(const bool value) + { + std::uint8_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); + bits = (value ? static_cast((bits) | (static_cast(1) << 5u)) : static_cast((bits) & ~(static_cast(1) << 5u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); + return *this; + } - static bool reserved4(const std::uint8_t bits) { - return (bits & (1u << 6u)) != 0; - } + static bool reserved4(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 6u)) != 0; + } - static std::uint8_t reserved4(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 6u)) - : static_cast(bits & ~(1u << 6u)); - } + static std::uint8_t reserved4(const std::uint8_t bits, const bool value) + { + return value ? static_cast(bits | (static_cast(1) << 6u)) : static_cast(bits & ~(static_cast(1) << 6u)); + } - SBE_NODISCARD bool reserved4() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 6u)) != 0; - } + SBE_NODISCARD bool reserved4() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 6u)) != 0; + } - ExecInst &reserved4(const bool value) { - std::uint8_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); - bits = - (value ? static_cast((bits) | (1u << 6u)) - : static_cast((bits) & ~(1u << 6u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); - return *this; - } + ExecInst &reserved4(const bool value) + { + std::uint8_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); + bits = (value ? static_cast((bits) | (static_cast(1) << 6u)) : static_cast((bits) & ~(static_cast(1) << 6u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); + return *this; + } - static bool reserved5(const std::uint8_t bits) { - return (bits & (1u << 7u)) != 0; - } + static bool reserved5(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 7u)) != 0; + } - static std::uint8_t reserved5(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 7u)) - : static_cast(bits & ~(1u << 7u)); - } + static std::uint8_t reserved5(const std::uint8_t bits, const bool value) + { + return value ? static_cast(bits | (static_cast(1) << 7u)) : static_cast(bits & ~(static_cast(1) << 7u)); + } - SBE_NODISCARD bool reserved5() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 7u)) != 0; - } + SBE_NODISCARD bool reserved5() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 7u)) != 0; + } - ExecInst &reserved5(const bool value) { - std::uint8_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); - bits = - (value ? static_cast((bits) | (1u << 7u)) - : static_cast((bits) & ~(1u << 7u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); - return *this; - } + ExecInst &reserved5(const bool value) + { + std::uint8_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint8_t)); + bits = (value ? static_cast((bits) | (static_cast(1) << 7u)) : static_cast((bits) & ~(static_cast(1) << 7u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint8_t)); + return *this; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, ExecInst writer) { - builder << '['; - bool atLeastOne = false; - if (writer.aON()) { - builder << R"("aON")"; - atLeastOne = true; - } - if (writer.oB()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("oB")"; - atLeastOne = true; - } - if (writer.nH()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("nH")"; - atLeastOne = true; - } - if (writer.reserved1()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("reserved1")"; - atLeastOne = true; - } - if (writer.reserved2()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("reserved2")"; - atLeastOne = true; - } - if (writer.reserved3()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("reserved3")"; - atLeastOne = true; - } - if (writer.reserved4()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("reserved4")"; - atLeastOne = true; - } - if (writer.reserved5()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("reserved5")"; - } - builder << ']'; - return builder; - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecInst writer) + { + builder << '['; + bool atLeastOne = false; + if (writer.aON()) + { + builder << R"("aON")"; + atLeastOne = true; + } + if (writer.oB()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("oB")"; + atLeastOne = true; + } + if (writer.nH()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("nH")"; + atLeastOne = true; + } + if (writer.reserved1()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("reserved1")"; + atLeastOne = true; + } + if (writer.reserved2()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("reserved2")"; + atLeastOne = true; + } + if (writer.reserved3()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("reserved3")"; + atLeastOne = true; + } + if (writer.reserved4()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("reserved4")"; + atLeastOne = true; + } + if (writer.reserved5()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("reserved5")"; + } + builder << ']'; + return builder; + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecMode.h b/src/lib/orderman/ilink3/generated/ExecMode.h index 03d3bdd61..bb894e61d 100644 --- a/src/lib/orderman/ilink3/generated/ExecMode.h +++ b/src/lib/orderman/ilink3/generated/ExecMode.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_EXECMODE_H_ #define _ILINKBINARY_EXECMODE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class ExecMode { - public: - enum Value { - Aggressive = (char)65, - Passive = (char)80, - NULL_VALUE = (char)0 - }; +class ExecMode +{ +public: + enum Value + { + Aggressive = static_cast(65), + Passive = static_cast(80), + NULL_VALUE = static_cast(0x00) + }; - static ExecMode::Value get(const char value) { - switch (value) { - case 65: - return Aggressive; - case 80: - return Passive; - case 0: - return NULL_VALUE; - } + static ExecMode::Value get(const char value) + { + switch (value) + { + case static_cast(65): return Aggressive; + case static_cast(80): return Passive; + case static_cast(0x00): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ExecMode [E103]"); - } + throw std::runtime_error("unknown value for enum ExecMode [E103]"); + } - static const char *c_str(const ExecMode::Value value) { - switch (value) { - case Aggressive: - return "Aggressive"; - case Passive: - return "Passive"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ExecMode::Value value) + { + switch (value) + { + case Aggressive: return "Aggressive"; + case Passive: return "Passive"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum ExecMode [E103]:"); - } + throw std::runtime_error("unknown value for enum ExecMode [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ExecMode::Value m) { - return os << ExecMode::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ExecMode::Value m) + { + return os << ExecMode::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecReason.h b/src/lib/orderman/ilink3/generated/ExecReason.h index 5c3853a70..7a95e048a 100644 --- a/src/lib/orderman/ilink3/generated/ExecReason.h +++ b/src/lib/orderman/ilink3/generated/ExecReason.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_EXECREASON_H_ #define _ILINKBINARY_EXECREASON_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,83 +25,78 @@ namespace iLinkBinary { -class ExecReason { - public: - enum Value { - MarketExchangeOption = (std::uint8_t)8, - CancelledNotBest = (std::uint8_t)9, - CancelOnDisconnect = (std::uint8_t)100, - SelfMatchPreventionOldestOrderCancelled = (std::uint8_t)103, - CancelOnGlobexCreditControlsViolation = (std::uint8_t)104, - CancelFromFirmsoft = (std::uint8_t)105, - CancelFromRiskManagementAPI = (std::uint8_t)106, - SelfMatchPreventionNewestOrderCancelled = (std::uint8_t)107, - Cancelduetovolquotedoptionorderrestedqtylessthanminordersize = - (std::uint8_t)108, - NULL_VALUE = (std::uint8_t)255 - }; +class ExecReason +{ +public: + enum Value + { + MarketExchangeOption = static_cast(8), + CancelledNotBest = static_cast(9), + CancelOnDisconnect = static_cast(100), + SelfMatchPreventionOldestOrderCancelled = static_cast(103), + CancelOnGlobexCreditControlsViolation = static_cast(104), + CancelFromFirmsoft = static_cast(105), + CancelFromRiskManagementAPI = static_cast(106), + SelfMatchPreventionNewestOrderCancelled = static_cast(107), + Cancelduetovolquotedoptionorderrestedqtylessthanminordersize = static_cast(108), + CancelRFCOrder = static_cast(109), + CancelUponContractExpiration = static_cast(110), + SystemCancel = static_cast(111), + NULL_VALUE = static_cast(255) + }; - static ExecReason::Value get(const std::uint8_t value) { - switch (value) { - case 8: - return MarketExchangeOption; - case 9: - return CancelledNotBest; - case 100: - return CancelOnDisconnect; - case 103: - return SelfMatchPreventionOldestOrderCancelled; - case 104: - return CancelOnGlobexCreditControlsViolation; - case 105: - return CancelFromFirmsoft; - case 106: - return CancelFromRiskManagementAPI; - case 107: - return SelfMatchPreventionNewestOrderCancelled; - case 108: - return Cancelduetovolquotedoptionorderrestedqtylessthanminordersize; - case 255: - return NULL_VALUE; - } + static ExecReason::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(8): return MarketExchangeOption; + case static_cast(9): return CancelledNotBest; + case static_cast(100): return CancelOnDisconnect; + case static_cast(103): return SelfMatchPreventionOldestOrderCancelled; + case static_cast(104): return CancelOnGlobexCreditControlsViolation; + case static_cast(105): return CancelFromFirmsoft; + case static_cast(106): return CancelFromRiskManagementAPI; + case static_cast(107): return SelfMatchPreventionNewestOrderCancelled; + case static_cast(108): return Cancelduetovolquotedoptionorderrestedqtylessthanminordersize; + case static_cast(109): return CancelRFCOrder; + case static_cast(110): return CancelUponContractExpiration; + case static_cast(111): return SystemCancel; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ExecReason [E103]"); - } + throw std::runtime_error("unknown value for enum ExecReason [E103]"); + } - static const char *c_str(const ExecReason::Value value) { - switch (value) { - case MarketExchangeOption: - return "MarketExchangeOption"; - case CancelledNotBest: - return "CancelledNotBest"; - case CancelOnDisconnect: - return "CancelOnDisconnect"; - case SelfMatchPreventionOldestOrderCancelled: - return "SelfMatchPreventionOldestOrderCancelled"; - case CancelOnGlobexCreditControlsViolation: - return "CancelOnGlobexCreditControlsViolation"; - case CancelFromFirmsoft: - return "CancelFromFirmsoft"; - case CancelFromRiskManagementAPI: - return "CancelFromRiskManagementAPI"; - case SelfMatchPreventionNewestOrderCancelled: - return "SelfMatchPreventionNewestOrderCancelled"; - case Cancelduetovolquotedoptionorderrestedqtylessthanminordersize: - return "Cancelduetovolquotedoptionorderrestedqtylessthanminordersize"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ExecReason::Value value) + { + switch (value) + { + case MarketExchangeOption: return "MarketExchangeOption"; + case CancelledNotBest: return "CancelledNotBest"; + case CancelOnDisconnect: return "CancelOnDisconnect"; + case SelfMatchPreventionOldestOrderCancelled: return "SelfMatchPreventionOldestOrderCancelled"; + case CancelOnGlobexCreditControlsViolation: return "CancelOnGlobexCreditControlsViolation"; + case CancelFromFirmsoft: return "CancelFromFirmsoft"; + case CancelFromRiskManagementAPI: return "CancelFromRiskManagementAPI"; + case SelfMatchPreventionNewestOrderCancelled: return "SelfMatchPreventionNewestOrderCancelled"; + case Cancelduetovolquotedoptionorderrestedqtylessthanminordersize: return "Cancelduetovolquotedoptionorderrestedqtylessthanminordersize"; + case CancelRFCOrder: return "CancelRFCOrder"; + case CancelUponContractExpiration: return "CancelUponContractExpiration"; + case SystemCancel: return "SystemCancel"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum ExecReason [E103]:"); - } + throw std::runtime_error("unknown value for enum ExecReason [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ExecReason::Value m) { - return os << ExecReason::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ExecReason::Value m) + { + return os << ExecReason::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecTypTrdCxl.h b/src/lib/orderman/ilink3/generated/ExecTypTrdCxl.h index 6b0fa1a7f..525bdce0f 100644 --- a/src/lib/orderman/ilink3/generated/ExecTypTrdCxl.h +++ b/src/lib/orderman/ilink3/generated/ExecTypTrdCxl.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_EXECTYPTRDCXL_H_ #define _ILINKBINARY_EXECTYPTRDCXL_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class ExecTypTrdCxl { - public: - enum Value { - TradeCorrection = (char)71, - TradeCancel = (char)72, - NULL_VALUE = (char)0 - }; +class ExecTypTrdCxl +{ +public: + enum Value + { + TradeCorrection = static_cast(71), + TradeCancel = static_cast(72), + NULL_VALUE = static_cast(0) + }; - static ExecTypTrdCxl::Value get(const char value) { - switch (value) { - case 71: - return TradeCorrection; - case 72: - return TradeCancel; - case 0: - return NULL_VALUE; - } + static ExecTypTrdCxl::Value get(const char value) + { + switch (value) + { + case static_cast(71): return TradeCorrection; + case static_cast(72): return TradeCancel; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ExecTypTrdCxl [E103]"); - } + throw std::runtime_error("unknown value for enum ExecTypTrdCxl [E103]"); + } - static const char *c_str(const ExecTypTrdCxl::Value value) { - switch (value) { - case TradeCorrection: - return "TradeCorrection"; - case TradeCancel: - return "TradeCancel"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ExecTypTrdCxl::Value value) + { + switch (value) + { + case TradeCorrection: return "TradeCorrection"; + case TradeCancel: return "TradeCancel"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum ExecTypTrdCxl [E103]:"); - } + throw std::runtime_error("unknown value for enum ExecTypTrdCxl [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ExecTypTrdCxl::Value m) { - return os << ExecTypTrdCxl::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ExecTypTrdCxl::Value m) + { + return os << ExecTypTrdCxl::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionAck539.h b/src/lib/orderman/ilink3/generated/ExecutionAck539.h index 4dea06638..1e5e6b802 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionAck539.h +++ b/src/lib/orderman/ilink3/generated/ExecutionAck539.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1646 +86,1850 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionAck539 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class ExecutionAck539 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(101); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(539); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - ExecutionAck539() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - ExecutionAck539( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - ExecutionAck539(char *buffer, const std::uint64_t bufferLength) - : ExecutionAck539( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + ExecutionAck539() = default; - ExecutionAck539( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionAck539( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + ExecutionAck539( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)101; - } + ExecutionAck539(char *buffer, const std::uint64_t bufferLength) : + ExecutionAck539(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + ExecutionAck539( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionAck539(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)539; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(101); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(539); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "BN"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - ExecutionAck539 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionAck539( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "BN"; + } - ExecutionAck539 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + ExecutionAck539 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionAck539(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = ExecutionAck539( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + ExecutionAck539 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - ExecutionAck539 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionAck539( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = ExecutionAck539( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + ExecutionAck539 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionAck539(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + ExecutionAck539 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionAck539 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionAck539 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionAck539 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionAck539 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionAck539 &orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionAck539 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecAckStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecAckStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execAckStatusId() SBE_NOEXCEPT { - return 1036; - } + static SBE_CONSTEXPR std::uint16_t execAckStatusId() SBE_NOEXCEPT + { + return 1036; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execAckStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execAckStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execAckStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execAckStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execAckStatusSinceVersion(); + return m_actingVersion >= execAckStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execAckStatusEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execAckStatusEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execAckStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execAckStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecAckStatus::Value execAckStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ExecAckStatus::get((val)); - } + SBE_NODISCARD std::uint8_t execAckStatusRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - ExecutionAck539 & - execAckStatus(const ExecAckStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ExecAckStatus::Value execAckStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ExecAckStatus::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionAck539 &execAckStatus(const ExecAckStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionAck539 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionAck539 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - ExecutionAck539 &clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + ExecutionAck539 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - ExecutionAck539 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + ExecutionAck539 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionAck539 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionAck539 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - ExecutionAck539 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + ExecutionAck539 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT { return 527; } + static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT + { + return 527; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - secExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t secExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= secExecIDSinceVersion(); + return m_actingVersion >= secExecIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - secExecIDEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t secExecIDEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionAck539 &secExecID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionAck539 &secExecID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT { return 31; } + static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT + { + return 31; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastPxSinceVersion(); + return m_actingVersion >= lastPxSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastPxEncodingOffset() SBE_NOEXCEPT { - return 49; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastPxEncodingOffset() SBE_NOEXCEPT + { + return 49; + } - private: - PRICE9 m_lastPx; +private: + PRICE9 m_lastPx; - public: - SBE_NODISCARD PRICE9 &lastPx() { - m_lastPx.wrap(m_buffer, m_offset + 49, m_actingVersion, m_bufferLength); - return m_lastPx; - } +public: + SBE_NODISCARD PRICE9 &lastPx() + { + m_lastPx.wrap(m_buffer, m_offset + 49, m_actingVersion, m_bufferLength); + return m_lastPx; + } - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 57; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 57; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 57, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 57, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionAck539 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 57, &val, sizeof(std::int32_t)); - return *this; - } + ExecutionAck539 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 57, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT { return 32; } + static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT + { + return 32; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastQtySinceVersion(); + return m_actingVersion >= lastQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastQtyEncodingOffset() SBE_NOEXCEPT { - return 61; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastQtyEncodingOffset() SBE_NOEXCEPT + { + return 61; + } - static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionAck539 &lastQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionAck539 &lastQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - DKReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DKReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t dKReasonId() SBE_NOEXCEPT { return 127; } + static SBE_CONSTEXPR std::uint16_t dKReasonId() SBE_NOEXCEPT + { + return 127; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - dKReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t dKReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool dKReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool dKReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= dKReasonSinceVersion(); + return m_actingVersion >= dKReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - dKReasonEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t dKReasonEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - dKReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t dKReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD DKReason::Value dKReason() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 65, sizeof(char)); - return DKReason::get((val)); - } + SBE_NODISCARD char dKReasonRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 65, sizeof(char)); + return (val); + } - ExecutionAck539 &dKReason(const DKReason::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 65, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD DKReason::Value dKReason() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 65, sizeof(char)); + return DKReason::get((val)); + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionAck539 &dKReason(const DKReason::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 65, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 66; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 66; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return (val); + } - ExecutionAck539 &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionAck539 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 67; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 67; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return nullptr; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return nullptr; + } - return m_buffer + m_offset + 67; - } + return m_buffer + m_offset + 67; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return nullptr; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return nullptr; + } - return m_buffer + m_offset + 67; - } + return m_buffer + m_offset + 67; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - if (m_actingVersion < 4) { - return (char)0; - } + if (m_actingVersion < 4) + { + return static_cast(0); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 67 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 67 + (index * 1), sizeof(char)); + return (val); + } - ExecutionAck539 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + ExecutionAck539 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 67 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 67 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - if (m_actingVersion < 4) { - return 0; - } + if (m_actingVersion < 4) + { + return 0; + } - std::memcpy( - dst, m_buffer + m_offset + 67, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 67, sizeof(char) * static_cast(length)); + return length; + } - ExecutionAck539 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 67, src, sizeof(char) * 20); - return *this; - } + ExecutionAck539 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 67, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 67; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 67; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + if (m_actingVersion < 4) + { + return std::string(""); + } - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + std::ostringstream oss; + std::string s = getSenderIDAsString(); - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 67; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 67; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionAck539 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionAck539 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 67, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 67 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 67, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 67 + start] = 0; + } - return *this; - } -#else - ExecutionAck539 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + ExecutionAck539 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 67, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 67 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 67, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 67 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 87; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 87; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - if (m_actingVersion < 5) { - return 0xffffffffffffffffL; - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + if (m_actingVersion < 5) + { + return UINT64_C(0xffffffffffffffff); + } - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionAck539 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionAck539 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 95; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 95; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - if (m_actingVersion < 5) { - return nullptr; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + if (m_actingVersion < 5) + { + return nullptr; + } - return m_buffer + m_offset + 95; - } + return m_buffer + m_offset + 95; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - if (m_actingVersion < 5) { - return nullptr; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + if (m_actingVersion < 5) + { + return nullptr; + } - return m_buffer + m_offset + 95; - } + return m_buffer + m_offset + 95; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - if (m_actingVersion < 5) { - return (char)0; - } + if (m_actingVersion < 5) + { + return static_cast(0); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 95 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 95 + (index * 1), sizeof(char)); + return (val); + } - ExecutionAck539 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + ExecutionAck539 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 95 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 95 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - if (m_actingVersion < 5) { - return 0; - } + if (m_actingVersion < 5) + { + return 0; + } - std::memcpy( - dst, m_buffer + m_offset + 95, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 95, sizeof(char) * static_cast(length)); + return length; + } - ExecutionAck539 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 95, src, sizeof(char) * 5); - return *this; - } + ExecutionAck539 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 95, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 95; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 95; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + if (m_actingVersion < 5) + { + return std::string(""); + } - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + std::ostringstream oss; + std::string s = getLocationAsString(); - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 95; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 95; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionAck539 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + ExecutionAck539 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 95, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 95 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 95, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 95 + start] = 0; + } - return *this; - } -#else - ExecutionAck539 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + ExecutionAck539 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 95, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 95 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 95, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 95 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 100; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 100; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - if (m_actingVersion < 5) { - return ManualOrdIndReq::NULL_VALUE; - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 5) + { + return static_cast(255); + } - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint8_t)); + return (val); + } - ExecutionAck539 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + if (m_actingVersion < 5) + { + return ManualOrdIndReq::NULL_VALUE; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, ExecutionAck539 _writer) { - ExecutionAck539 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionAck539", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + ExecutionAck539 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint8_t)); + return *this; + } - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionAck539 _writer) +{ + ExecutionAck539 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("ExecAckStatus": )"; - builder << '"' << writer.execAckStatus() << '"'; + builder << '{'; + builder << R"("Name": "ExecutionAck539", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("SecExecID": )"; - builder << +writer.secExecID(); + builder << ", "; + builder << R"("ExecAckStatus": )"; + builder << '"' << writer.execAckStatus() << '"'; - builder << ", "; - builder << R"("LastPx": )"; - builder << writer.lastPx(); + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("LastQty": )"; - builder << +writer.lastQty(); + builder << ", "; + builder << R"("SecExecID": )"; + builder << +writer.secExecID(); - builder << ", "; - builder << R"("DKReason": )"; - builder << '"' << writer.dKReason() << '"'; + builder << ", "; + builder << R"("LastPx": )"; + builder << writer.lastPx(); - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("LastQty": )"; + builder << +writer.lastQty(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("DKReason": )"; + builder << '"' << writer.dKReason() << '"'; - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << '}'; + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - return builder; - } + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - void skip() {} + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportCancel534.h b/src/lib/orderman/ilink3/generated/ExecutionReportCancel534.h index 7d8e85e53..1f6459986 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportCancel534.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportCancel534.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3324 +86,4320 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportCancel534 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class ExecutionReportCancel534 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(247); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(534); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - ExecutionReportCancel534() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - ExecutionReportCancel534( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - ExecutionReportCancel534(char *buffer, const std::uint64_t bufferLength) - : ExecutionReportCancel534( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + ExecutionReportCancel534() = default; - ExecutionReportCancel534( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportCancel534( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + ExecutionReportCancel534( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)214; - } + ExecutionReportCancel534(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportCancel534(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + ExecutionReportCancel534( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportCancel534(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)534; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(247); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(534); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - ExecutionReportCancel534 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportCancel534( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } - ExecutionReportCancel534 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + ExecutionReportCancel534 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportCancel534(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = ExecutionReportCancel534( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + ExecutionReportCancel534 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - ExecutionReportCancel534 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportCancel534( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = ExecutionReportCancel534( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + ExecutionReportCancel534 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportCancel534(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + ExecutionReportCancel534 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportCancel534 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportCancel534 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportCancel534 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportCancel534 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportCancel534 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportCancel534 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportCancel534 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } + ExecutionReportCancel534 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportCancel534 &putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } + ExecutionReportCancel534 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportCancel534 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportCancel534 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - ExecutionReportCancel534 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + return *this; + } + #else + ExecutionReportCancel534 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportCancel534 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + ExecutionReportCancel534 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportCancel534 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } + ExecutionReportCancel534 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportCancel534 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportCancel534 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#else - ExecutionReportCancel534 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + ExecutionReportCancel534 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportCancel534 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + ExecutionReportCancel534 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportCancel534 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } + ExecutionReportCancel534 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportCancel534 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportCancel534 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#else - ExecutionReportCancel534 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + ExecutionReportCancel534 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 92; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportCancel534 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportCancel534 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 100; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 100; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportCancel534 &orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportCancel534 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceSinceVersion(); + return m_actingVersion >= priceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 108; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 108; + } - private: - PRICE9 m_price; +private: + PRICE9 m_price; - public: - SBE_NODISCARD PRICE9 &price() { - m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); - return m_price; - } +public: + SBE_NODISCARD PRICE9 &price() + { + m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); + return m_price; + } - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= stopPxSinceVersion(); + return m_actingVersion >= stopPxSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 116; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 116; + } - private: - PRICENULL9 m_stopPx; +private: + PRICENULL9 m_stopPx; - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); - return m_stopPx; - } +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); + return m_stopPx; + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transactTimeSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 124; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 124; + } - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportCancel534 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportCancel534 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 132; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 132; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportCancel534 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportCancel534 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 140; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 140; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportCancel534 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportCancel534 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT { return 548; } + static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT + { + return 548; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossIDSinceVersion(); + return m_actingVersion >= crossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossIDEncodingOffset() SBE_NOEXCEPT { - return 148; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossIDEncodingOffset() SBE_NOEXCEPT + { + return 148; + } - static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportCancel534 &crossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportCancel534 &crossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT { - return 961; - } + static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT + { + return 961; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hostCrossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hostCrossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hostCrossIDSinceVersion(); + return m_actingVersion >= hostCrossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hostCrossIDEncodingOffset() SBE_NOEXCEPT { - return 156; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hostCrossIDEncodingOffset() SBE_NOEXCEPT + { + return 156; + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportCancel534 & - hostCrossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportCancel534 &hostCrossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 164; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 164; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 164; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 164; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 164; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 164; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 164 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 164 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportCancel534 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + ExecutionReportCancel534 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 164 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 164 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 164, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 164, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportCancel534 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 164, src, sizeof(char) * 5); - return *this; - } + ExecutionReportCancel534 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 164, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 164; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 164; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 164; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 164; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportCancel534 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportCancel534 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 164, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 164 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 164, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 164 + start] = 0; + } - return *this; - } -#else - ExecutionReportCancel534 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + ExecutionReportCancel534 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 164, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 164 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 164, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 164 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 169; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 169; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportCancel534 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::int32_t)); - return *this; - } + ExecutionReportCancel534 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderQtySinceVersion(); + return m_actingVersion >= orderQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 173; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 173; + } - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportCancel534 &orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportCancel534 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT { return 14; } + static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cumQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cumQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cumQtySinceVersion(); + return m_actingVersion >= cumQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cumQtyEncodingOffset() SBE_NOEXCEPT { - return 177; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cumQtyEncodingOffset() SBE_NOEXCEPT + { + return 177; + } - static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportCancel534 &cumQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportCancel534 &cumQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT { return 110; } + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minQtySinceVersion(); + return m_actingVersion >= minQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minQtyEncodingOffset() SBE_NOEXCEPT { - return 181; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 181; + } - static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportCancel534 &minQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportCancel534 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT { - return 1138; - } + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayQtySinceVersion(); + return m_actingVersion >= displayQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayQtyEncodingOffset() SBE_NOEXCEPT { - return 185; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 185; + } - static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportCancel534 & - displayQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportCancel534 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= expireDateSinceVersion(); + return m_actingVersion >= expireDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportCancel534 & - expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportCancel534 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 191; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 191; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportCancel534 & - delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 191, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportCancel534 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 191, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusSinceVersion(); + return m_actingVersion >= ordStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *ordStatus() const { - static const std::uint8_t ordStatusValues[] = {52}; + SBE_NODISCARD const char *ordStatus() const + { + static const std::uint8_t ordStatusValues[] = { 52, 0 }; - return (const char *)ordStatusValues; - } + return (const char *)ordStatusValues; + } - SBE_NODISCARD char ordStatus(const std::uint64_t index) const { - static const std::uint8_t ordStatusValues[] = {52}; + SBE_NODISCARD char ordStatus(const std::uint64_t index) const + { + static const std::uint8_t ordStatusValues[] = { 52, 0 }; - return (char)ordStatusValues[index]; - } + return (char)ordStatusValues[index]; + } - std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const { - static std::uint8_t ordStatusValues[] = {52}; - std::uint64_t bytesToCopy = - length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); + std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordStatusValues[] = { 52 }; + std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); - std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getOrdStatusAsString() const { - static const std::uint8_t OrdStatusValues[] = {52}; + std::string getOrdStatusAsString() const + { + static const std::uint8_t OrdStatusValues[] = { 52 }; - return std::string((const char *)OrdStatusValues, 1); - } + return std::string((const char *)OrdStatusValues, 1); + } - std::string getOrdStatusAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrdStatusAsString(); + std::string getOrdStatusAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrdStatusAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execTypeSinceVersion(); + return m_actingVersion >= execTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *execType() const { - static const std::uint8_t execTypeValues[] = {52}; + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 52, 0 }; - return (const char *)execTypeValues; - } + return (const char *)execTypeValues; + } - SBE_NODISCARD char execType(const std::uint64_t index) const { - static const std::uint8_t execTypeValues[] = {52}; + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 52, 0 }; - return (char)execTypeValues[index]; - } + return (char)execTypeValues[index]; + } - std::uint64_t getExecType(char *dst, const std::uint64_t length) const { - static std::uint8_t execTypeValues[] = {52}; - std::uint64_t bytesToCopy = - length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 52 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); - std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getExecTypeAsString() const { - static const std::uint8_t ExecTypeValues[] = {52}; + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 52 }; - return std::string((const char *)ExecTypeValues, 1); - } + return std::string((const char *)ExecTypeValues, 1); + } - std::string getExecTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecTypeAsString(); + std::string getExecTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 193, sizeof(char)); - return OrderType::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(char)); + return (val); + } - ExecutionReportCancel534 & - ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 193, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(char)); + return OrderType::get((val)); + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportCancel534 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 193, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 194; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 194; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 194, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportCancel534 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 194, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 195; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 195; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 & - timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportCancel534 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 196; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 196; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 196, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 196, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 196, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 196, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportCancel534 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 196, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 197; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 197; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 197, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportCancel534 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 197, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 198; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 198; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 & - splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 198, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char *ExecRestatementReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportCancel534 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 198, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t execRestatementReasonId() SBE_NOEXCEPT { - return 378; - } + SBE_NODISCARD static const char *ExecRestatementReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execRestatementReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t execRestatementReasonId() SBE_NOEXCEPT + { + return 378; + } - SBE_NODISCARD bool execRestatementReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execRestatementReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execRestatementReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execRestatementReasonSinceVersion(); + return m_actingVersion >= execRestatementReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execRestatementReasonEncodingOffset() SBE_NOEXCEPT { - return 199; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execRestatementReasonEncodingOffset() SBE_NOEXCEPT + { + return 199; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execRestatementReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execRestatementReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecReason::Value execRestatementReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); - return ExecReason::get((val)); - } + SBE_NODISCARD std::uint8_t execRestatementReasonRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 & - execRestatementReason(const ExecReason::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ExecReason::Value execRestatementReason() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); + return ExecReason::get((val)); + } - SBE_NODISCARD static const char * - CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportCancel534 &execRestatementReason(const ExecReason::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT { return 549; } + SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT + { + return 549; + } - SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossTypeSinceVersion(); + return m_actingVersion >= crossTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossTypeEncodingOffset() SBE_NOEXCEPT { - return 200; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossTypeEncodingOffset() SBE_NOEXCEPT + { + return 200; + } - static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 &crossType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 200, &val, sizeof(std::uint8_t)); - return *this; - } + ExecutionReportCancel534 &crossType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 200, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execInstSinceVersion(); + return m_actingVersion >= execInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 201; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 201; + } - private: - ExecInst m_execInst; +private: + ExecInst m_execInst; - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 201, m_actingVersion, m_bufferLength); - return m_execInst; - } +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 201, m_actingVersion, m_bufferLength); + return m_execInst; + } - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executionModeSinceVersion(); + return m_actingVersion >= executionModeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 202; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 202; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 202, sizeof(char)); - return ExecMode::get((val)); - } + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 202, sizeof(char)); + return (val); + } - ExecutionReportCancel534 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 202, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 202, sizeof(char)); + return ExecMode::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportCancel534 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 202, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 203; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 203; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 203, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 203, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 203, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 203, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportCancel534 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 203, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= managedOrderSinceVersion(); + return m_actingVersion >= managedOrderSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 204; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 204; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 204, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 204, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 204, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 204, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportCancel534 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 204, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= shortSaleTypeSinceVersion(); + return m_actingVersion >= shortSaleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 205; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 205; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 205, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 205, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportCancel534 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 205, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 205, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportCancel534 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 205, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 206; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 206; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return 0xffffffffffffffffL; - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return UINT64_C(0xffffffffffffffff); + } - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 206, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 206, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportCancel534 & - delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 206, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportCancel534 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 206, &val, sizeof(std::uint64_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportCancel534 _writer) { - ExecutionReportCancel534 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportCancel534", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 214; + } - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; +private: + PRICENULL9 m_discretionPrice; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 214, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + SBE_NODISCARD static const char *ReservationPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("Price": )"; - builder << writer.price(); + static SBE_CONSTEXPR std::uint16_t reservationPriceId() SBE_NOEXCEPT + { + return 9562; + } - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reservationPriceSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + SBE_NODISCARD bool reservationPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reservationPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reservationPriceEncodingOffset() SBE_NOEXCEPT + { + return 222; + } - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); +private: + PRICENULL9 m_reservationPrice; - builder << ", "; - builder << R"("CrossID": )"; - builder << +writer.crossID(); +public: + SBE_NODISCARD PRICENULL9 &reservationPrice() + { + m_reservationPrice.wrap(m_buffer, m_offset + 222, m_actingVersion, m_bufferLength); + return m_reservationPrice; + } - builder << ", "; - builder << R"("HostCrossID": )"; - builder << +writer.hostCrossID(); + SBE_NODISCARD static const char *PriorityIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + static SBE_CONSTEXPR std::uint16_t priorityIndicatorId() SBE_NOEXCEPT + { + return 638; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priorityIndicatorSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); + SBE_NODISCARD bool priorityIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priorityIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("CumQty": )"; - builder << +writer.cumQty(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 230; + } - builder << ", "; - builder << R"("MinQty": )"; - builder << +writer.minQty(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - builder << ", "; - builder << R"("DisplayQty": )"; - builder << +writer.displayQty(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); + static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + SBE_NODISCARD std::uint8_t priorityIndicator() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 230, sizeof(std::uint8_t)); + return (val); + } - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + ExecutionReportCancel534 &priorityIndicator(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 230, &val, sizeof(std::uint8_t)); + return *this; + } - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + SBE_NODISCARD static const char *OrigOrderUserMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + static SBE_CONSTEXPR std::uint16_t origOrderUserId() SBE_NOEXCEPT + { + return 9937; + } - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origOrderUserSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("ExecRestatementReason": )"; - builder << '"' << writer.execRestatementReason() << '"'; + SBE_NODISCARD bool origOrderUserInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origOrderUserSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("CrossType": )"; - builder << +writer.crossType(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origOrderUserEncodingOffset() SBE_NOEXCEPT + { + return 231; + } - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + static SBE_CONSTEXPR char origOrderUserNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + static SBE_CONSTEXPR char origOrderUserMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + static SBE_CONSTEXPR char origOrderUserMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + static SBE_CONSTEXPR std::size_t origOrderUserEncodingLength() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + static SBE_CONSTEXPR std::uint64_t origOrderUserLength() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); + SBE_NODISCARD const char *origOrderUser() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } - builder << '}'; + return m_buffer + m_offset + 231; + } - return builder; - } + SBE_NODISCARD char *origOrderUser() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } - void skip() {} + return m_buffer + m_offset + 231; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + SBE_NODISCARD char origOrderUser(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E104]"); + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 231 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportCancel534 &origOrderUser(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 231 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrigOrderUser(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getOrigOrderUser [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 231, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportCancel534 &putOrigOrderUser(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 231, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getOrigOrderUserAsString() const + { + const char *buffer = m_buffer + m_offset + 231; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrigOrderUserAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrigOrderUserAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrigOrderUserAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 231; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportCancel534 &putOrigOrderUser(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 231, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 231 + start] = 0; + } + + return *this; + } + #else + ExecutionReportCancel534 &putOrigOrderUser(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 231, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 231 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *CancelTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cancelTextId() SBE_NOEXCEPT + { + return 2807; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cancelTextSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool cancelTextInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cancelTextSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cancelTextEncodingOffset() SBE_NOEXCEPT + { + return 239; + } + + static SBE_CONSTEXPR char cancelTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char cancelTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char cancelTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t cancelTextEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t cancelTextLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *cancelText() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 239; + } + + SBE_NODISCARD char *cancelText() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 239; + } + + SBE_NODISCARD char cancelText(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 239 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportCancel534 &cancelText(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 239 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getCancelText(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getCancelText [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 239, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportCancel534 &putCancelText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 239, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getCancelTextAsString() const + { + const char *buffer = m_buffer + m_offset + 239; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getCancelTextAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getCancelTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCancelTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 239; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportCancel534 &putCancelText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 239, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 239 + start] = 0; + } + + return *this; + } + #else + ExecutionReportCancel534 &putCancelText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 239, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 239 + start] = 0; + } + + return *this; + } + #endif + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportCancel534 _writer) +{ + ExecutionReportCancel534 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "ExecutionReportCancel534", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); + + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("CrossID": )"; + builder << +writer.crossID(); + + builder << ", "; + builder << R"("HostCrossID": )"; + builder << +writer.hostCrossID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("CumQty": )"; + builder << +writer.cumQty(); + + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); + + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); + + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); + + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + builder << R"("ExecRestatementReason": )"; + builder << '"' << writer.execRestatementReason() << '"'; + + builder << ", "; + builder << R"("CrossType": )"; + builder << +writer.crossType(); + + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); + + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("ReservationPrice": )"; + if (writer.reservationPriceInActingVersion()) + { + builder << writer.reservationPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("PriorityIndicator": )"; + builder << +writer.priorityIndicator(); + + builder << ", "; + builder << R"("OrigOrderUser": )"; + builder << '"' << + writer.getOrigOrderUserAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("CancelText": )"; + builder << '"' << + writer.getCancelTextAsJsonEscapedString().c_str() << '"'; + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportElimination524.h b/src/lib/orderman/ilink3/generated/ExecutionReportElimination524.h index 69f9f6612..bab8055c5 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportElimination524.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportElimination524.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3077 +86,3559 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportElimination524 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class ExecutionReportElimination524 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(219); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(524); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - ExecutionReportElimination524() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - ExecutionReportElimination524( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - ExecutionReportElimination524(char *buffer, const std::uint64_t bufferLength) - : ExecutionReportElimination524( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + ExecutionReportElimination524() = default; - ExecutionReportElimination524( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportElimination524( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + ExecutionReportElimination524( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)202; - } + ExecutionReportElimination524(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportElimination524(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + ExecutionReportElimination524( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportElimination524(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)524; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(219); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(524); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - ExecutionReportElimination524 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportElimination524( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } - ExecutionReportElimination524 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + ExecutionReportElimination524 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportElimination524(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = ExecutionReportElimination524( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + ExecutionReportElimination524 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - ExecutionReportElimination524 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportElimination524( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = ExecutionReportElimination524( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + ExecutionReportElimination524 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportElimination524(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + ExecutionReportElimination524 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportElimination524 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportElimination524 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportElimination524 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportElimination524 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportElimination524 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportElimination524 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportElimination524 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } + ExecutionReportElimination524 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportElimination524 & - putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } + ExecutionReportElimination524 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportElimination524 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportElimination524 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - ExecutionReportElimination524 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + return *this; + } + #else + ExecutionReportElimination524 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportElimination524 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + ExecutionReportElimination524 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportElimination524 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } + ExecutionReportElimination524 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportElimination524 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportElimination524 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#else - ExecutionReportElimination524 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + ExecutionReportElimination524 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportElimination524 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + ExecutionReportElimination524 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportElimination524 & - putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } + ExecutionReportElimination524 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportElimination524 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportElimination524 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#else - ExecutionReportElimination524 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + ExecutionReportElimination524 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 92; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportElimination524 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportElimination524 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 100; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 100; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportElimination524 & - orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportElimination524 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceSinceVersion(); + return m_actingVersion >= priceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 108; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 108; + } - private: - PRICE9 m_price; +private: + PRICE9 m_price; - public: - SBE_NODISCARD PRICE9 &price() { - m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); - return m_price; - } +public: + SBE_NODISCARD PRICE9 &price() + { + m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); + return m_price; + } - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= stopPxSinceVersion(); + return m_actingVersion >= stopPxSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 116; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 116; + } - private: - PRICENULL9 m_stopPx; +private: + PRICENULL9 m_stopPx; - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); - return m_stopPx; - } +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); + return m_stopPx; + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transactTimeSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 124; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 124; + } - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportElimination524 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportElimination524 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 132; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 132; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportElimination524 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportElimination524 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 140; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 140; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportElimination524 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportElimination524 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT { return 548; } + static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT + { + return 548; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossIDSinceVersion(); + return m_actingVersion >= crossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossIDEncodingOffset() SBE_NOEXCEPT { - return 148; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossIDEncodingOffset() SBE_NOEXCEPT + { + return 148; + } - static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportElimination524 & - crossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportElimination524 &crossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT { - return 961; - } + static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT + { + return 961; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hostCrossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hostCrossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hostCrossIDSinceVersion(); + return m_actingVersion >= hostCrossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hostCrossIDEncodingOffset() SBE_NOEXCEPT { - return 156; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hostCrossIDEncodingOffset() SBE_NOEXCEPT + { + return 156; + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportElimination524 & - hostCrossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportElimination524 &hostCrossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 164; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 164; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 164; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 164; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 164; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 164; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 164 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 164 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportElimination524 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + ExecutionReportElimination524 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 164 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 164 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 164, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 164, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportElimination524 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 164, src, sizeof(char) * 5); - return *this; - } + ExecutionReportElimination524 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 164, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 164; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 164; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 164; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 164; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportElimination524 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportElimination524 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 164, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 164 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 164, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 164 + start] = 0; + } - return *this; - } -#else - ExecutionReportElimination524 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + ExecutionReportElimination524 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 164, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 164 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 164, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 164 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 169; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 169; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportElimination524 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::int32_t)); - return *this; - } + ExecutionReportElimination524 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT { return 14; } + static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cumQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cumQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cumQtySinceVersion(); + return m_actingVersion >= cumQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cumQtyEncodingOffset() SBE_NOEXCEPT { - return 173; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cumQtyEncodingOffset() SBE_NOEXCEPT + { + return 173; + } - static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportElimination524 & - cumQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportElimination524 &cumQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderQtySinceVersion(); + return m_actingVersion >= orderQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 177; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 177; + } - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportElimination524 & - orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportElimination524 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT { return 110; } + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minQtySinceVersion(); + return m_actingVersion >= minQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minQtyEncodingOffset() SBE_NOEXCEPT { - return 181; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 181; + } - static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportElimination524 & - minQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportElimination524 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT { - return 1138; - } + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayQtySinceVersion(); + return m_actingVersion >= displayQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayQtyEncodingOffset() SBE_NOEXCEPT { - return 185; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 185; + } - static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportElimination524 & - displayQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportElimination524 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusSinceVersion(); + return m_actingVersion >= ordStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *ordStatus() const { - static const std::uint8_t ordStatusValues[] = {67}; + SBE_NODISCARD const char *ordStatus() const + { + static const std::uint8_t ordStatusValues[] = { 67, 0 }; - return (const char *)ordStatusValues; - } + return (const char *)ordStatusValues; + } - SBE_NODISCARD char ordStatus(const std::uint64_t index) const { - static const std::uint8_t ordStatusValues[] = {67}; + SBE_NODISCARD char ordStatus(const std::uint64_t index) const + { + static const std::uint8_t ordStatusValues[] = { 67, 0 }; - return (char)ordStatusValues[index]; - } + return (char)ordStatusValues[index]; + } - std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const { - static std::uint8_t ordStatusValues[] = {67}; - std::uint64_t bytesToCopy = - length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); + std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordStatusValues[] = { 67 }; + std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); - std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getOrdStatusAsString() const { - static const std::uint8_t OrdStatusValues[] = {67}; + std::string getOrdStatusAsString() const + { + static const std::uint8_t OrdStatusValues[] = { 67 }; - return std::string((const char *)OrdStatusValues, 1); - } + return std::string((const char *)OrdStatusValues, 1); + } - std::string getOrdStatusAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrdStatusAsString(); + std::string getOrdStatusAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrdStatusAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execTypeSinceVersion(); + return m_actingVersion >= execTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *execType() const { - static const std::uint8_t execTypeValues[] = {67}; + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 67, 0 }; - return (const char *)execTypeValues; - } + return (const char *)execTypeValues; + } - SBE_NODISCARD char execType(const std::uint64_t index) const { - static const std::uint8_t execTypeValues[] = {67}; + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 67, 0 }; - return (char)execTypeValues[index]; - } + return (char)execTypeValues[index]; + } - std::uint64_t getExecType(char *dst, const std::uint64_t length) const { - static std::uint8_t execTypeValues[] = {67}; - std::uint64_t bytesToCopy = - length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 67 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); - std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getExecTypeAsString() const { - static const std::uint8_t ExecTypeValues[] = {67}; + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 67 }; - return std::string((const char *)ExecTypeValues, 1); - } + return std::string((const char *)ExecTypeValues, 1); + } - std::string getExecTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecTypeAsString(); + std::string getExecTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= expireDateSinceVersion(); + return m_actingVersion >= expireDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportElimination524 & - expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportElimination524 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 191; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 191; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 191, sizeof(char)); - return OrderType::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 191, sizeof(char)); + return (val); + } - ExecutionReportElimination524 & - ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 191, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 191, sizeof(char)); + return OrderType::get((val)); + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportElimination524 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 191, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 192; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 192; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportElimination524 & - side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 192, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportElimination524 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 192, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportElimination524 & - timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportElimination524 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 194; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 194; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportElimination524 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 194, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportElimination524 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 194, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 195; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 195; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportElimination524 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportElimination524 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT { return 549; } + SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT + { + return 549; + } - SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossTypeSinceVersion(); + return m_actingVersion >= crossTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossTypeEncodingOffset() SBE_NOEXCEPT { - return 196; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossTypeEncodingOffset() SBE_NOEXCEPT + { + return 196; + } - static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 196, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 196, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportElimination524 & - crossType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 196, &val, sizeof(std::uint8_t)); - return *this; - } + ExecutionReportElimination524 &crossType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 196, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execInstSinceVersion(); + return m_actingVersion >= execInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 197; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 197; + } - private: - ExecInst m_execInst; +private: + ExecInst m_execInst; - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 197, m_actingVersion, m_bufferLength); - return m_execInst; - } +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 197, m_actingVersion, m_bufferLength); + return m_execInst; + } - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executionModeSinceVersion(); + return m_actingVersion >= executionModeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 198; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 198; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 198, sizeof(char)); - return ExecMode::get((val)); - } + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(char)); + return (val); + } - ExecutionReportElimination524 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 198, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(char)); + return ExecMode::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportElimination524 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 198, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 199; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 199; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportElimination524 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportElimination524 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= managedOrderSinceVersion(); + return m_actingVersion >= managedOrderSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 200; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 200; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportElimination524 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 200, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportElimination524 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 200, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= shortSaleTypeSinceVersion(); + return m_actingVersion >= shortSaleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 201; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 201; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportElimination524 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportElimination524 _writer) { - ExecutionReportElimination524 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportElimination524", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + ExecutionReportElimination524 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 202; + } - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); +private: + PRICENULL9 m_discretionPrice; - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 202, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } - builder << ", "; - builder << R"("Price": )"; - builder << writer.price(); + SBE_NODISCARD static const char *ReservationPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); + static SBE_CONSTEXPR std::uint16_t reservationPriceId() SBE_NOEXCEPT + { + return 9562; + } - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reservationPriceSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + SBE_NODISCARD bool reservationPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reservationPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reservationPriceEncodingOffset() SBE_NOEXCEPT + { + return 210; + } - builder << ", "; - builder << R"("CrossID": )"; - builder << +writer.crossID(); +private: + PRICENULL9 m_reservationPrice; - builder << ", "; - builder << R"("HostCrossID": )"; - builder << +writer.hostCrossID(); +public: + SBE_NODISCARD PRICENULL9 &reservationPrice() + { + m_reservationPrice.wrap(m_buffer, m_offset + 210, m_actingVersion, m_bufferLength); + return m_reservationPrice; + } - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static const char *PriorityIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + static SBE_CONSTEXPR std::uint16_t priorityIndicatorId() SBE_NOEXCEPT + { + return 638; + } - builder << ", "; - builder << R"("CumQty": )"; - builder << +writer.cumQty(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priorityIndicatorSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); + SBE_NODISCARD bool priorityIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priorityIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("MinQty": )"; - builder << +writer.minQty(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 218; + } - builder << ", "; - builder << R"("DisplayQty": )"; - builder << +writer.displayQty(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + SBE_NODISCARD std::uint8_t priorityIndicator() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 218, sizeof(std::uint8_t)); + return (val); + } - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + ExecutionReportElimination524 &priorityIndicator(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 218, &val, sizeof(std::uint8_t)); + return *this; + } - builder << ", "; - builder << R"("CrossType": )"; - builder << +writer.crossType(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportElimination524 _writer) +{ + ExecutionReportElimination524 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + builder << '{'; + builder << R"("Name": "ExecutionReportElimination524", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << '}'; + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - return builder; - } + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - void skip() {} + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("CrossID": )"; + builder << +writer.crossID(); + + builder << ", "; + builder << R"("HostCrossID": )"; + builder << +writer.hostCrossID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("CumQty": )"; + builder << +writer.cumQty(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); + + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); + + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("CrossType": )"; + builder << +writer.crossType(); + + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("ReservationPrice": )"; + if (writer.reservationPriceInActingVersion()) + { + builder << writer.reservationPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("PriorityIndicator": )"; + builder << +writer.priorityIndicator(); + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportModify531.h b/src/lib/orderman/ilink3/generated/ExecutionReportModify531.h index 010655a8e..69e2be133 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportModify531.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportModify531.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3332 +86,3798 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportModify531 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class ExecutionReportModify531 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(226); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(531); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - ExecutionReportModify531() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - ExecutionReportModify531( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - ExecutionReportModify531(char *buffer, const std::uint64_t bufferLength) - : ExecutionReportModify531( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + ExecutionReportModify531() = default; - ExecutionReportModify531( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportModify531( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + ExecutionReportModify531( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)217; - } + ExecutionReportModify531(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportModify531(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + ExecutionReportModify531( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportModify531(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)531; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(226); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(531); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - ExecutionReportModify531 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportModify531( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } - ExecutionReportModify531 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + ExecutionReportModify531 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportModify531(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = ExecutionReportModify531( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + ExecutionReportModify531 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - ExecutionReportModify531 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportModify531( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = ExecutionReportModify531( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + ExecutionReportModify531 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportModify531(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + ExecutionReportModify531 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportModify531 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportModify531 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportModify531 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportModify531 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportModify531 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportModify531 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportModify531 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } + ExecutionReportModify531 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportModify531 &putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } + ExecutionReportModify531 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportModify531 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportModify531 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - ExecutionReportModify531 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + return *this; + } + #else + ExecutionReportModify531 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportModify531 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + ExecutionReportModify531 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportModify531 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } + ExecutionReportModify531 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportModify531 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportModify531 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#else - ExecutionReportModify531 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + ExecutionReportModify531 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportModify531 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + ExecutionReportModify531 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportModify531 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } + ExecutionReportModify531 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportModify531 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportModify531 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#else - ExecutionReportModify531 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + ExecutionReportModify531 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 92; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportModify531 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportModify531 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 100; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 100; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportModify531 &orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportModify531 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceSinceVersion(); + return m_actingVersion >= priceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 108; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 108; + } - private: - PRICE9 m_price; +private: + PRICE9 m_price; - public: - SBE_NODISCARD PRICE9 &price() { - m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); - return m_price; - } +public: + SBE_NODISCARD PRICE9 &price() + { + m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); + return m_price; + } - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= stopPxSinceVersion(); + return m_actingVersion >= stopPxSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 116; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 116; + } - private: - PRICENULL9 m_stopPx; +private: + PRICENULL9 m_stopPx; - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); - return m_stopPx; - } +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); + return m_stopPx; + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transactTimeSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 124; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 124; + } - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportModify531 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportModify531 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 132; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 132; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportModify531 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportModify531 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 140; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 140; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportModify531 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportModify531 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT { return 548; } + static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT + { + return 548; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossIDSinceVersion(); + return m_actingVersion >= crossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossIDEncodingOffset() SBE_NOEXCEPT { - return 148; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossIDEncodingOffset() SBE_NOEXCEPT + { + return 148; + } - static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportModify531 &crossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportModify531 &crossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT { - return 961; - } + static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT + { + return 961; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hostCrossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hostCrossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hostCrossIDSinceVersion(); + return m_actingVersion >= hostCrossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hostCrossIDEncodingOffset() SBE_NOEXCEPT { - return 156; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hostCrossIDEncodingOffset() SBE_NOEXCEPT + { + return 156; + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportModify531 & - hostCrossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportModify531 &hostCrossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 164; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 164; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 164; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 164; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 164; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 164; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 164 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 164 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportModify531 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + ExecutionReportModify531 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 164 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 164 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 164, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 164, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportModify531 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 164, src, sizeof(char) * 5); - return *this; - } + ExecutionReportModify531 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 164, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 164; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 164; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 164; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 164; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportModify531 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportModify531 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 164, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 164 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 164, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 164 + start] = 0; + } - return *this; - } -#else - ExecutionReportModify531 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + ExecutionReportModify531 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 164, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 164 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 164, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 164 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 169; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 169; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportModify531 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::int32_t)); - return *this; - } + ExecutionReportModify531 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderQtySinceVersion(); + return m_actingVersion >= orderQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 173; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 173; + } - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportModify531 &orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportModify531 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT { return 14; } + static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cumQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cumQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cumQtySinceVersion(); + return m_actingVersion >= cumQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cumQtyEncodingOffset() SBE_NOEXCEPT { - return 177; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cumQtyEncodingOffset() SBE_NOEXCEPT + { + return 177; + } - static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportModify531 &cumQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportModify531 &cumQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT { return 151; } + static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT + { + return 151; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - leavesQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t leavesQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= leavesQtySinceVersion(); + return m_actingVersion >= leavesQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - leavesQtyEncodingOffset() SBE_NOEXCEPT { - return 181; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t leavesQtyEncodingOffset() SBE_NOEXCEPT + { + return 181; + } - static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportModify531 &leavesQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportModify531 &leavesQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT { return 110; } + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minQtySinceVersion(); + return m_actingVersion >= minQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minQtyEncodingOffset() SBE_NOEXCEPT { - return 185; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 185; + } - static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportModify531 &minQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportModify531 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT { - return 1138; - } + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayQtySinceVersion(); + return m_actingVersion >= displayQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayQtyEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportModify531 & - displayQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportModify531 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= expireDateSinceVersion(); + return m_actingVersion >= expireDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportModify531 & - expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportModify531 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 195; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 195; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportModify531 & - delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportModify531 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusSinceVersion(); + return m_actingVersion >= ordStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 197; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 197; + } - static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *ordStatus() const { - static const std::uint8_t ordStatusValues[] = {53}; + SBE_NODISCARD const char *ordStatus() const + { + static const std::uint8_t ordStatusValues[] = { 53, 0 }; - return (const char *)ordStatusValues; - } + return (const char *)ordStatusValues; + } - SBE_NODISCARD char ordStatus(const std::uint64_t index) const { - static const std::uint8_t ordStatusValues[] = {53}; + SBE_NODISCARD char ordStatus(const std::uint64_t index) const + { + static const std::uint8_t ordStatusValues[] = { 53, 0 }; - return (char)ordStatusValues[index]; - } + return (char)ordStatusValues[index]; + } - std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const { - static std::uint8_t ordStatusValues[] = {53}; - std::uint64_t bytesToCopy = - length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); + std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordStatusValues[] = { 53 }; + std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); - std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getOrdStatusAsString() const { - static const std::uint8_t OrdStatusValues[] = {53}; + std::string getOrdStatusAsString() const + { + static const std::uint8_t OrdStatusValues[] = { 53 }; - return std::string((const char *)OrdStatusValues, 1); - } + return std::string((const char *)OrdStatusValues, 1); + } - std::string getOrdStatusAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrdStatusAsString(); + std::string getOrdStatusAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrdStatusAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execTypeSinceVersion(); + return m_actingVersion >= execTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 197; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 197; + } - static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *execType() const { - static const std::uint8_t execTypeValues[] = {53}; + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 53, 0 }; - return (const char *)execTypeValues; - } + return (const char *)execTypeValues; + } - SBE_NODISCARD char execType(const std::uint64_t index) const { - static const std::uint8_t execTypeValues[] = {53}; + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 53, 0 }; - return (char)execTypeValues[index]; - } + return (char)execTypeValues[index]; + } - std::uint64_t getExecType(char *dst, const std::uint64_t length) const { - static std::uint8_t execTypeValues[] = {53}; - std::uint64_t bytesToCopy = - length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 53 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); - std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getExecTypeAsString() const { - static const std::uint8_t ExecTypeValues[] = {53}; + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 53 }; - return std::string((const char *)ExecTypeValues, 1); - } + return std::string((const char *)ExecTypeValues, 1); + } - std::string getExecTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecTypeAsString(); + std::string getExecTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 197; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 197; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 197, sizeof(char)); - return OrderType::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(char)); + return (val); + } - ExecutionReportModify531 & - ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 197, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(char)); + return OrderType::get((val)); + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportModify531 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 197, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 198; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 198; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportModify531 &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 198, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportModify531 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 198, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 199; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 199; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportModify531 & - timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportModify531 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 200; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 200; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportModify531 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 200, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportModify531 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 200, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 201; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 201; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportModify531 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportModify531 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 202; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 202; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 202, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 202, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportModify531 & - splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 202, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 202, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char * - CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportModify531 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 202, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT { return 549; } + SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT + { + return 549; + } - SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossTypeSinceVersion(); + return m_actingVersion >= crossTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossTypeEncodingOffset() SBE_NOEXCEPT { - return 203; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossTypeEncodingOffset() SBE_NOEXCEPT + { + return 203; + } - static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 203, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 203, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportModify531 &crossType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 203, &val, sizeof(std::uint8_t)); - return *this; - } + ExecutionReportModify531 &crossType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 203, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execInstSinceVersion(); + return m_actingVersion >= execInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 204; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 204; + } - private: - ExecInst m_execInst; +private: + ExecInst m_execInst; - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 204, m_actingVersion, m_bufferLength); - return m_execInst; - } +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 204, m_actingVersion, m_bufferLength); + return m_execInst; + } - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executionModeSinceVersion(); + return m_actingVersion >= executionModeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 205; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 205; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 205, sizeof(char)); - return ExecMode::get((val)); - } + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 205, sizeof(char)); + return (val); + } - ExecutionReportModify531 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 205, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 205, sizeof(char)); + return ExecMode::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportModify531 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 205, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 206; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 206; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 206, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 206, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportModify531 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 206, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 206, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportModify531 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 206, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= managedOrderSinceVersion(); + return m_actingVersion >= managedOrderSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 207; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 207; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 207, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 207, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportModify531 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 207, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 207, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportModify531 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 207, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= shortSaleTypeSinceVersion(); + return m_actingVersion >= shortSaleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 208; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 208; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 208, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 208, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportModify531 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 208, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 208, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportModify531 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 208, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 209; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 209; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return 0xffffffffffffffffL; - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return UINT64_C(0xffffffffffffffff); + } - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 209, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 209, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportModify531 & - delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 209, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportModify531 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 209, &val, sizeof(std::uint64_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportModify531 _writer) { - ExecutionReportModify531 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportModify531", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 217; + } - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; +private: + PRICENULL9 m_discretionPrice; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 217, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + SBE_NODISCARD static const char *PriorityIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - builder << ", "; - builder << R"("Price": )"; - builder << writer.price(); + static SBE_CONSTEXPR std::uint16_t priorityIndicatorId() SBE_NOEXCEPT + { + return 638; + } - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priorityIndicatorSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + SBE_NODISCARD bool priorityIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priorityIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 225; + } - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - builder << ", "; - builder << R"("CrossID": )"; - builder << +writer.crossID(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - builder << ", "; - builder << R"("HostCrossID": )"; - builder << +writer.hostCrossID(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + SBE_NODISCARD std::uint8_t priorityIndicator() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 225, sizeof(std::uint8_t)); + return (val); + } - builder << ", "; - builder << R"("CumQty": )"; - builder << +writer.cumQty(); + ExecutionReportModify531 &priorityIndicator(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 225, &val, sizeof(std::uint8_t)); + return *this; + } - builder << ", "; - builder << R"("LeavesQty": )"; - builder << +writer.leavesQty(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportModify531 _writer) +{ + ExecutionReportModify531 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("MinQty": )"; - builder << +writer.minQty(); + builder << '{'; + builder << R"("Name": "ExecutionReportModify531", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("DisplayQty": )"; - builder << +writer.displayQty(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); - builder << ", "; - builder << R"("CrossType": )"; - builder << +writer.crossType(); + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("CrossID": )"; + builder << +writer.crossID(); - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + builder << ", "; + builder << R"("HostCrossID": )"; + builder << +writer.hostCrossID(); - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << '}'; + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); - return builder; - } + builder << ", "; + builder << R"("CumQty": )"; + builder << +writer.cumQty(); - void skip() {} + builder << ", "; + builder << R"("LeavesQty": )"; + builder << +writer.leavesQty(); - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); + + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); + + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + builder << R"("CrossType": )"; + builder << +writer.crossType(); + + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); + + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("PriorityIndicator": )"; + builder << +writer.priorityIndicator(); + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportNew522.h b/src/lib/orderman/ilink3/generated/ExecutionReportNew522.h index 9bdec2e02..29cf6dad9 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportNew522.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportNew522.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3189 +86,3706 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportNew522 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class ExecutionReportNew522 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(226); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(522); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - ExecutionReportNew522() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - ExecutionReportNew522( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - ExecutionReportNew522(char *buffer, const std::uint64_t bufferLength) - : ExecutionReportNew522( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + ExecutionReportNew522() = default; - ExecutionReportNew522( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportNew522( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + ExecutionReportNew522( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)209; - } + ExecutionReportNew522(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportNew522(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + ExecutionReportNew522( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportNew522(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)522; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(226); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(522); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - ExecutionReportNew522 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportNew522( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } - ExecutionReportNew522 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + ExecutionReportNew522 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportNew522(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = ExecutionReportNew522( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + ExecutionReportNew522 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - ExecutionReportNew522 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportNew522( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = ExecutionReportNew522( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + ExecutionReportNew522 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportNew522(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + ExecutionReportNew522 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportNew522 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportNew522 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportNew522 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportNew522 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportNew522 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportNew522 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportNew522 &execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } + ExecutionReportNew522 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportNew522 &putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } + ExecutionReportNew522 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportNew522 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportNew522 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - ExecutionReportNew522 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + return *this; + } + #else + ExecutionReportNew522 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportNew522 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + ExecutionReportNew522 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportNew522 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } + ExecutionReportNew522 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportNew522 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportNew522 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#else - ExecutionReportNew522 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + ExecutionReportNew522 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportNew522 &clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + ExecutionReportNew522 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportNew522 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } + ExecutionReportNew522 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportNew522 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportNew522 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#else - ExecutionReportNew522 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + ExecutionReportNew522 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 92; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportNew522 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportNew522 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 100; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 100; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportNew522 &orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportNew522 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceSinceVersion(); + return m_actingVersion >= priceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 108; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 108; + } - private: - PRICE9 m_price; +private: + PRICE9 m_price; - public: - SBE_NODISCARD PRICE9 &price() { - m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); - return m_price; - } +public: + SBE_NODISCARD PRICE9 &price() + { + m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); + return m_price; + } - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= stopPxSinceVersion(); + return m_actingVersion >= stopPxSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 116; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 116; + } - private: - PRICENULL9 m_stopPx; +private: + PRICENULL9 m_stopPx; - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); - return m_stopPx; - } +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); + return m_stopPx; + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transactTimeSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 124; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 124; + } - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportNew522 &transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportNew522 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 132; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 132; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportNew522 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportNew522 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 140; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 140; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportNew522 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportNew522 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT { return 548; } + static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT + { + return 548; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossIDSinceVersion(); + return m_actingVersion >= crossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossIDEncodingOffset() SBE_NOEXCEPT { - return 148; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossIDEncodingOffset() SBE_NOEXCEPT + { + return 148; + } - static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportNew522 &crossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportNew522 &crossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT { - return 961; - } + static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT + { + return 961; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hostCrossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hostCrossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hostCrossIDSinceVersion(); + return m_actingVersion >= hostCrossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hostCrossIDEncodingOffset() SBE_NOEXCEPT { - return 156; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hostCrossIDEncodingOffset() SBE_NOEXCEPT + { + return 156; + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportNew522 &hostCrossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportNew522 &hostCrossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 164; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 164; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 164; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 164; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 164; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 164; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 164 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 164 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportNew522 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + ExecutionReportNew522 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 164 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 164 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 164, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 164, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportNew522 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 164, src, sizeof(char) * 5); - return *this; - } + ExecutionReportNew522 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 164, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 164; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 164; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 164; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 164; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportNew522 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportNew522 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 164, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 164 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 164, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 164 + start] = 0; + } - return *this; - } -#else - ExecutionReportNew522 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + ExecutionReportNew522 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 164, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 164 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 164, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 164 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 169; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 169; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportNew522 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::int32_t)); - return *this; - } + ExecutionReportNew522 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderQtySinceVersion(); + return m_actingVersion >= orderQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 173; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 173; + } - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportNew522 &orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportNew522 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT { return 110; } + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minQtySinceVersion(); + return m_actingVersion >= minQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minQtyEncodingOffset() SBE_NOEXCEPT { - return 177; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 177; + } - static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportNew522 &minQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportNew522 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT { - return 1138; - } + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayQtySinceVersion(); + return m_actingVersion >= displayQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayQtyEncodingOffset() SBE_NOEXCEPT { - return 181; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 181; + } - static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportNew522 &displayQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportNew522 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= expireDateSinceVersion(); + return m_actingVersion >= expireDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 185; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 185; + } - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportNew522 &expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportNew522 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 187; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 187; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 187, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 187, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportNew522 & - delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 187, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportNew522 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 187, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusSinceVersion(); + return m_actingVersion >= ordStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *ordStatus() const { - static const std::uint8_t ordStatusValues[] = {48}; + SBE_NODISCARD const char *ordStatus() const + { + static const std::uint8_t ordStatusValues[] = { 48, 0 }; - return (const char *)ordStatusValues; - } + return (const char *)ordStatusValues; + } - SBE_NODISCARD char ordStatus(const std::uint64_t index) const { - static const std::uint8_t ordStatusValues[] = {48}; + SBE_NODISCARD char ordStatus(const std::uint64_t index) const + { + static const std::uint8_t ordStatusValues[] = { 48, 0 }; - return (char)ordStatusValues[index]; - } + return (char)ordStatusValues[index]; + } - std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const { - static std::uint8_t ordStatusValues[] = {48}; - std::uint64_t bytesToCopy = - length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); + std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordStatusValues[] = { 48 }; + std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); - std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getOrdStatusAsString() const { - static const std::uint8_t OrdStatusValues[] = {48}; + std::string getOrdStatusAsString() const + { + static const std::uint8_t OrdStatusValues[] = { 48 }; - return std::string((const char *)OrdStatusValues, 1); - } + return std::string((const char *)OrdStatusValues, 1); + } - std::string getOrdStatusAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrdStatusAsString(); + std::string getOrdStatusAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrdStatusAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execTypeSinceVersion(); + return m_actingVersion >= execTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *execType() const { - static const std::uint8_t execTypeValues[] = {48}; + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 48, 0 }; - return (const char *)execTypeValues; - } + return (const char *)execTypeValues; + } - SBE_NODISCARD char execType(const std::uint64_t index) const { - static const std::uint8_t execTypeValues[] = {48}; + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 48, 0 }; - return (char)execTypeValues[index]; - } + return (char)execTypeValues[index]; + } - std::uint64_t getExecType(char *dst, const std::uint64_t length) const { - static std::uint8_t execTypeValues[] = {48}; - std::uint64_t bytesToCopy = - length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 48 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); - std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getExecTypeAsString() const { - static const std::uint8_t ExecTypeValues[] = {48}; + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 48 }; - return std::string((const char *)ExecTypeValues, 1); - } + return std::string((const char *)ExecTypeValues, 1); + } - std::string getExecTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecTypeAsString(); + std::string getExecTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 189, sizeof(char)); - return OrderType::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(char)); + return (val); + } - ExecutionReportNew522 &ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 189, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(char)); + return OrderType::get((val)); + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportNew522 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 190; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 190; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 190, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 190, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportNew522 &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 190, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 190, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportNew522 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 190, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 191; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 191; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportNew522 & - timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 191, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportNew522 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 191, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 192; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 192; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportNew522 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 192, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportNew522 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 192, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportNew522 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportNew522 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 194; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 194; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportNew522 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 194, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char * - CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportNew522 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 194, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT { return 549; } + SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT + { + return 549; + } - SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossTypeSinceVersion(); + return m_actingVersion >= crossTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossTypeEncodingOffset() SBE_NOEXCEPT { - return 195; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossTypeEncodingOffset() SBE_NOEXCEPT + { + return 195; + } - static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportNew522 &crossType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint8_t)); - return *this; - } + ExecutionReportNew522 &crossType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execInstSinceVersion(); + return m_actingVersion >= execInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 196; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 196; + } - private: - ExecInst m_execInst; +private: + ExecInst m_execInst; - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 196, m_actingVersion, m_bufferLength); - return m_execInst; - } +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 196, m_actingVersion, m_bufferLength); + return m_execInst; + } - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executionModeSinceVersion(); + return m_actingVersion >= executionModeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 197; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 197; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 197, sizeof(char)); - return ExecMode::get((val)); - } + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(char)); + return (val); + } - ExecutionReportNew522 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 197, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(char)); + return ExecMode::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportNew522 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 197, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 198; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 198; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportNew522 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 198, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportNew522 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 198, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= managedOrderSinceVersion(); + return m_actingVersion >= managedOrderSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 199; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 199; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportNew522 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportNew522 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= shortSaleTypeSinceVersion(); + return m_actingVersion >= shortSaleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 200; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 200; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportNew522 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 200, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 200, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportNew522 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 200, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 201; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 201; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return 0xffffffffffffffffL; - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return UINT64_C(0xffffffffffffffff); + } - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportNew522 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportNew522 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint64_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportNew522 _writer) { - ExecutionReportNew522 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportNew522", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 209; + } - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; +private: + PRICENULL9 m_discretionPrice; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 209, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + SBE_NODISCARD static const char *ReservationPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("Price": )"; - builder << writer.price(); + static SBE_CONSTEXPR std::uint16_t reservationPriceId() SBE_NOEXCEPT + { + return 9562; + } - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reservationPriceSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + SBE_NODISCARD bool reservationPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reservationPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reservationPriceEncodingOffset() SBE_NOEXCEPT + { + return 217; + } - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); +private: + PRICENULL9 m_reservationPrice; - builder << ", "; - builder << R"("CrossID": )"; - builder << +writer.crossID(); +public: + SBE_NODISCARD PRICENULL9 &reservationPrice() + { + m_reservationPrice.wrap(m_buffer, m_offset + 217, m_actingVersion, m_bufferLength); + return m_reservationPrice; + } - builder << ", "; - builder << R"("HostCrossID": )"; - builder << +writer.hostCrossID(); + SBE_NODISCARD static const char *PriorityIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + static SBE_CONSTEXPR std::uint16_t priorityIndicatorId() SBE_NOEXCEPT + { + return 638; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priorityIndicatorSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); + SBE_NODISCARD bool priorityIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priorityIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("MinQty": )"; - builder << +writer.minQty(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 225; + } - builder << ", "; - builder << R"("DisplayQty": )"; - builder << +writer.displayQty(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + SBE_NODISCARD std::uint8_t priorityIndicator() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 225, sizeof(std::uint8_t)); + return (val); + } - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + ExecutionReportNew522 &priorityIndicator(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 225, &val, sizeof(std::uint8_t)); + return *this; + } - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportNew522 _writer) +{ + ExecutionReportNew522 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << '{'; + builder << R"("Name": "ExecutionReportNew522", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("CrossType": )"; - builder << +writer.crossType(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << '}'; + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); - return builder; - } + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); - void skip() {} + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("CrossID": )"; + builder << +writer.crossID(); + + builder << ", "; + builder << R"("HostCrossID": )"; + builder << +writer.hostCrossID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); + + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); + + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); + + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + builder << R"("CrossType": )"; + builder << +writer.crossType(); + + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); + + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("ReservationPrice": )"; + if (writer.reservationPriceInActingVersion()) + { + builder << writer.reservationPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("PriorityIndicator": )"; + builder << +writer.priorityIndicator(); + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportPendingCancel564.h b/src/lib/orderman/ilink3/generated/ExecutionReportPendingCancel564.h new file mode 100644 index 000000000..d750eacdb --- /dev/null +++ b/src/lib/orderman/ilink3/generated/ExecutionReportPendingCancel564.h @@ -0,0 +1,3803 @@ +/* Generated SBE (Simple Binary Encoding) message codec */ +#ifndef _ILINKBINARY_EXECUTIONREPORTPENDINGCANCEL564_H_ +#define _ILINKBINARY_EXECUTIONREPORTPENDINGCANCEL564_H_ + +#if defined(SBE_HAVE_CMATH) +/* cmath needed for std::numeric_limits::quiet_NaN() */ +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +#else +/* math.h needed for NAN */ +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN +#endif + +#if __cplusplus >= 201103L +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept +#else +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT +#endif + +#if __cplusplus >= 201703L +# include +# define SBE_NODISCARD [[nodiscard]] +#else +# define SBE_NODISCARD +#endif + +#if !defined(__STDC_LIMIT_MACROS) +# define __STDC_LIMIT_MACROS 1 +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(WIN32) || defined(_WIN32) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +#else +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +#endif + +#if defined(SBE_NO_BOUNDS_CHECK) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +#elif defined(_MSC_VER) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +#else +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +#endif + +#define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() +#define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() +#define SBE_NULLVALUE_INT32 (std::numeric_limits::min)() +#define SBE_NULLVALUE_INT64 (std::numeric_limits::min)() +#define SBE_NULLVALUE_UINT8 (std::numeric_limits::max)() +#define SBE_NULLVALUE_UINT16 (std::numeric_limits::max)() +#define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() +#define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + + +#include "MaturityMonthYear.h" +#include "Decimal64NULL.h" +#include "OrderTypeReq.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" +#include "PRICENULL9.h" +#include "BooleanFlag.h" +#include "OrderType.h" +#include "QuoteCxlStatus.h" +#include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" +#include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" + +namespace iLinkBinary { + +class ExecutionReportPendingCancel564 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(219); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(564); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + ExecutionReportPendingCancel564() = default; + + ExecutionReportPendingCancel564( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + ExecutionReportPendingCancel564(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportPendingCancel564(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + ExecutionReportPendingCancel564( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportPendingCancel564(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(219); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(564); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + ExecutionReportPendingCancel564 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportPendingCancel564(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + ExecutionReportPendingCancel564 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = ExecutionReportPendingCancel564( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + ExecutionReportPendingCancel564 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportPendingCancel564(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + ExecutionReportPendingCancel564 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } + + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } + + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportPendingCancel564 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } + + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } + + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } + + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } + + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= seqNumSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingCancel564 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= uUIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingCancel564 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } + + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } + + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingCancel564 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingCancel564 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } + + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingCancel564 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingCancel564 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= senderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } + + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } + + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } + + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingCancel564 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingCancel564 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingCancel564 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingCancel564 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= clOrdIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } + + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingCancel564 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingCancel564 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingCancel564 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingCancel564 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingCancel564 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 100; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingCancel564 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 108; + } + +private: + PRICE9 m_price; + +public: + SBE_NODISCARD PRICE9 &price() + { + m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); + return m_price; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= transactTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 116; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingCancel564 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 124; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingCancel564 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderRequestIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 132; + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingCancel564 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 140; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 140; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 140; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 140 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingCancel564 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 140 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 140, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingCancel564 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 140, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 140; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 140; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingCancel564 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 140, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 140 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingCancel564 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 140, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 140 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 145; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 145, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingCancel564 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 145, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 149; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 149, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingCancel564 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 149, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT + { + return 14; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cumQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cumQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cumQtyEncodingOffset() SBE_NOEXCEPT + { + return 153; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 153, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingCancel564 &cumQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 153, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT + { + return 151; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t leavesQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= leavesQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t leavesQtyEncodingOffset() SBE_NOEXCEPT + { + return 157; + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingCancel564 &leavesQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= minQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 161; + } + + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingCancel564 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= displayQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 165; + } + + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 165, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingCancel564 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 165, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= expireDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 169; + } + + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportPendingCancel564 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordStatusSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 171; + } + + static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *ordStatus() const + { + static const std::uint8_t ordStatusValues[] = { 54, 0 }; + + return (const char *)ordStatusValues; + } + + SBE_NODISCARD char ordStatus(const std::uint64_t index) const + { + static const std::uint8_t ordStatusValues[] = { 54, 0 }; + + return (char)ordStatusValues[index]; + } + + std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordStatusValues[] = { 54 }; + std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); + + std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getOrdStatusAsString() const + { + static const std::uint8_t OrdStatusValues[] = { 54 }; + + return std::string((const char *)OrdStatusValues, 1); + } + + std::string getOrdStatusAsJsonEscapedString() + { + if (m_actingVersion < 6) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrdStatusAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 171; + } + + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 54, 0 }; + + return (const char *)execTypeValues; + } + + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 54, 0 }; + + return (char)execTypeValues[index]; + } + + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 54 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 54 }; + + return std::string((const char *)ExecTypeValues, 1); + } + + std::string getExecTypeAsJsonEscapedString() + { + if (m_actingVersion < 6) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getExecTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 171; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); + return (val); + } + + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); + return OrderType::get((val)); + } + + ExecutionReportPendingCancel564 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 171, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 172; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + ExecutionReportPendingCancel564 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 172, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= timeInForceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 173; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } + + ExecutionReportPendingCancel564 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= manualOrderIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 174; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } + + ExecutionReportPendingCancel564 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 174, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= possRetransFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 175; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportPendingCancel564 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 175, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= splitMsgSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 176; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 176, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 176, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } + + ExecutionReportPendingCancel564 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 176, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= liquidityFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 177; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + ExecutionReportPendingCancel564 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= delayToTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 178; + } + + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 178, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingCancel564 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 178, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 186; + } + +private: + PRICENULL9 m_discretionPrice; + +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 186, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } + + SBE_NODISCARD static const char *ReservationPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t reservationPriceId() SBE_NOEXCEPT + { + return 9562; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reservationPriceSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool reservationPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reservationPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reservationPriceEncodingOffset() SBE_NOEXCEPT + { + return 194; + } + +private: + PRICENULL9 m_reservationPrice; + +public: + SBE_NODISCARD PRICENULL9 &reservationPrice() + { + m_reservationPrice.wrap(m_buffer, m_offset + 194, m_actingVersion, m_bufferLength); + return m_reservationPrice; + } + + SBE_NODISCARD static const char *PriorityIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t priorityIndicatorId() SBE_NOEXCEPT + { + return 638; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priorityIndicatorSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool priorityIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priorityIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 202; + } + + static SBE_CONSTEXPR std::uint8_t priorityIndicatorNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t priorityIndicator() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 202, sizeof(std::uint8_t)); + return (val); + } + + ExecutionReportPendingCancel564 &priorityIndicator(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 202, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrigOrderUserMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origOrderUserId() SBE_NOEXCEPT + { + return 9937; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origOrderUserSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool origOrderUserInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origOrderUserSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origOrderUserEncodingOffset() SBE_NOEXCEPT + { + return 203; + } + + static SBE_CONSTEXPR char origOrderUserNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char origOrderUserMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char origOrderUserMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t origOrderUserEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t origOrderUserLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *origOrderUser() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 203; + } + + SBE_NODISCARD char *origOrderUser() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 203; + } + + SBE_NODISCARD char origOrderUser(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 203 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingCancel564 &origOrderUser(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 203 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrigOrderUser(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getOrigOrderUser [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 203, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingCancel564 &putOrigOrderUser(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 203, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getOrigOrderUserAsString() const + { + const char *buffer = m_buffer + m_offset + 203; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrigOrderUserAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrigOrderUserAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrigOrderUserAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 203; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingCancel564 &putOrigOrderUser(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 203, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 203 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingCancel564 &putOrigOrderUser(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 203, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 203 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *CancelTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cancelTextId() SBE_NOEXCEPT + { + return 2807; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cancelTextSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool cancelTextInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cancelTextSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cancelTextEncodingOffset() SBE_NOEXCEPT + { + return 211; + } + + static SBE_CONSTEXPR char cancelTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char cancelTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char cancelTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t cancelTextEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t cancelTextLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *cancelText() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 211; + } + + SBE_NODISCARD char *cancelText() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 211; + } + + SBE_NODISCARD char cancelText(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 211 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingCancel564 &cancelText(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 211 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getCancelText(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getCancelText [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 211, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingCancel564 &putCancelText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 211, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getCancelTextAsString() const + { + const char *buffer = m_buffer + m_offset + 211; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getCancelTextAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getCancelTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCancelTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 211; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingCancel564 &putCancelText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 211, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 211 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingCancel564 &putCancelText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 211, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 211 + start] = 0; + } + + return *this; + } + #endif + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportPendingCancel564 _writer) +{ + ExecutionReportPendingCancel564 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "ExecutionReportPendingCancel564", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("CumQty": )"; + builder << +writer.cumQty(); + + builder << ", "; + builder << R"("LeavesQty": )"; + builder << +writer.leavesQty(); + + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); + + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); + + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); + + builder << ", "; + builder << R"("DiscretionPrice": )"; + builder << writer.discretionPrice(); + + builder << ", "; + builder << R"("ReservationPrice": )"; + if (writer.reservationPriceInActingVersion()) + { + builder << writer.reservationPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("PriorityIndicator": )"; + builder << +writer.priorityIndicator(); + + builder << ", "; + builder << R"("OrigOrderUser": )"; + builder << '"' << + writer.getOrigOrderUserAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("CancelText": )"; + builder << '"' << + writer.getCancelTextAsJsonEscapedString().c_str() << '"'; + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} +}; +} +#endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportPendingReplace565.h b/src/lib/orderman/ilink3/generated/ExecutionReportPendingReplace565.h new file mode 100644 index 000000000..40cb541f7 --- /dev/null +++ b/src/lib/orderman/ilink3/generated/ExecutionReportPendingReplace565.h @@ -0,0 +1,3340 @@ +/* Generated SBE (Simple Binary Encoding) message codec */ +#ifndef _ILINKBINARY_EXECUTIONREPORTPENDINGREPLACE565_H_ +#define _ILINKBINARY_EXECUTIONREPORTPENDINGREPLACE565_H_ + +#if defined(SBE_HAVE_CMATH) +/* cmath needed for std::numeric_limits::quiet_NaN() */ +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +#else +/* math.h needed for NAN */ +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN +#endif + +#if __cplusplus >= 201103L +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept +#else +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT +#endif + +#if __cplusplus >= 201703L +# include +# define SBE_NODISCARD [[nodiscard]] +#else +# define SBE_NODISCARD +#endif + +#if !defined(__STDC_LIMIT_MACROS) +# define __STDC_LIMIT_MACROS 1 +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(WIN32) || defined(_WIN32) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +#else +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +#endif + +#if defined(SBE_NO_BOUNDS_CHECK) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +#elif defined(_MSC_VER) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +#else +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +#endif + +#define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() +#define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() +#define SBE_NULLVALUE_INT32 (std::numeric_limits::min)() +#define SBE_NULLVALUE_INT64 (std::numeric_limits::min)() +#define SBE_NULLVALUE_UINT8 (std::numeric_limits::max)() +#define SBE_NULLVALUE_UINT16 (std::numeric_limits::max)() +#define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() +#define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + + +#include "MaturityMonthYear.h" +#include "Decimal64NULL.h" +#include "OrderTypeReq.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" +#include "PRICENULL9.h" +#include "BooleanFlag.h" +#include "OrderType.h" +#include "QuoteCxlStatus.h" +#include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" +#include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" + +namespace iLinkBinary { + +class ExecutionReportPendingReplace565 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(196); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(565); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + ExecutionReportPendingReplace565() = default; + + ExecutionReportPendingReplace565( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + ExecutionReportPendingReplace565(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportPendingReplace565(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + ExecutionReportPendingReplace565( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportPendingReplace565(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(196); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(565); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + ExecutionReportPendingReplace565 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportPendingReplace565(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + ExecutionReportPendingReplace565 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = ExecutionReportPendingReplace565( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + ExecutionReportPendingReplace565 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportPendingReplace565(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + ExecutionReportPendingReplace565 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } + + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } + + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportPendingReplace565 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } + + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } + + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } + + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } + + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= seqNumSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingReplace565 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= uUIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingReplace565 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } + + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } + + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingReplace565 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingReplace565 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } + + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingReplace565 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingReplace565 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= senderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } + + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } + + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } + + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingReplace565 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingReplace565 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingReplace565 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingReplace565 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= clOrdIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } + + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingReplace565 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingReplace565 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingReplace565 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingReplace565 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingReplace565 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 100; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingReplace565 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 108; + } + +private: + PRICE9 m_price; + +public: + SBE_NODISCARD PRICE9 &price() + { + m_price.wrap(m_buffer, m_offset + 108, m_actingVersion, m_bufferLength); + return m_price; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= transactTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 116; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingReplace565 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 124; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingReplace565 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderRequestIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 132; + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingReplace565 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 140; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 140; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 140; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 140 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportPendingReplace565 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 140 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 140, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportPendingReplace565 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 140, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 140; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 140; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportPendingReplace565 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 140, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 140 + start] = 0; + } + + return *this; + } + #else + ExecutionReportPendingReplace565 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 140, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 140 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 145; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 145, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingReplace565 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 145, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 149; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 149, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingReplace565 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 149, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT + { + return 14; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cumQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cumQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cumQtyEncodingOffset() SBE_NOEXCEPT + { + return 153; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 153, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingReplace565 &cumQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 153, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT + { + return 151; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t leavesQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= leavesQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t leavesQtyEncodingOffset() SBE_NOEXCEPT + { + return 157; + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingReplace565 &leavesQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= minQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 161; + } + + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingReplace565 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= displayQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 165; + } + + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 165, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportPendingReplace565 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 165, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= expireDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 169; + } + + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportPendingReplace565 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordStatusSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 171; + } + + static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *ordStatus() const + { + static const std::uint8_t ordStatusValues[] = { 69, 0 }; + + return (const char *)ordStatusValues; + } + + SBE_NODISCARD char ordStatus(const std::uint64_t index) const + { + static const std::uint8_t ordStatusValues[] = { 69, 0 }; + + return (char)ordStatusValues[index]; + } + + std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordStatusValues[] = { 69 }; + std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); + + std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getOrdStatusAsString() const + { + static const std::uint8_t OrdStatusValues[] = { 69 }; + + return std::string((const char *)OrdStatusValues, 1); + } + + std::string getOrdStatusAsJsonEscapedString() + { + if (m_actingVersion < 6) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrdStatusAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 171; + } + + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 69, 0 }; + + return (const char *)execTypeValues; + } + + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 69, 0 }; + + return (char)execTypeValues[index]; + } + + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 69 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 69 }; + + return std::string((const char *)ExecTypeValues, 1); + } + + std::string getExecTypeAsJsonEscapedString() + { + if (m_actingVersion < 6) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getExecTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 171; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); + return (val); + } + + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); + return OrderType::get((val)); + } + + ExecutionReportPendingReplace565 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 171, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 172; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + ExecutionReportPendingReplace565 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 172, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= timeInForceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 173; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } + + ExecutionReportPendingReplace565 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= manualOrderIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 174; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } + + ExecutionReportPendingReplace565 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 174, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= possRetransFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 175; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportPendingReplace565 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 175, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= splitMsgSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 176; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 176, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 176, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } + + ExecutionReportPendingReplace565 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 176, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= liquidityFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 177; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + ExecutionReportPendingReplace565 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= shortSaleTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 178; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 178, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 178, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } + + ExecutionReportPendingReplace565 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 178, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= delayToTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 179; + } + + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 179, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportPendingReplace565 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 179, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 187; + } + +private: + PRICENULL9 m_discretionPrice; + +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 187, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } + + SBE_NODISCARD static const char *PriorityIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t priorityIndicatorId() SBE_NOEXCEPT + { + return 638; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priorityIndicatorSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool priorityIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priorityIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 195; + } + + static SBE_CONSTEXPR std::uint8_t priorityIndicatorNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t priorityIndicator() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); + return (val); + } + + ExecutionReportPendingReplace565 &priorityIndicator(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint8_t)); + return *this; + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportPendingReplace565 _writer) +{ + ExecutionReportPendingReplace565 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "ExecutionReportPendingReplace565", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("CumQty": )"; + builder << +writer.cumQty(); + + builder << ", "; + builder << R"("LeavesQty": )"; + builder << +writer.leavesQty(); + + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); + + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); + + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); + + builder << ", "; + builder << R"("DiscretionPrice": )"; + builder << writer.discretionPrice(); + + builder << ", "; + builder << R"("PriorityIndicator": )"; + builder << +writer.priorityIndicator(); + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} +}; +} +#endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportReject523.h b/src/lib/orderman/ilink3/generated/ExecutionReportReject523.h index ffa01f8a5..8c5393eda 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportReject523.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportReject523.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3456 +86,3912 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportReject523 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class ExecutionReportReject523 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(483); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(523); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - ExecutionReportReject523() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - ExecutionReportReject523( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - ExecutionReportReject523(char *buffer, const std::uint64_t bufferLength) - : ExecutionReportReject523( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + ExecutionReportReject523() = default; - ExecutionReportReject523( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportReject523( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + ExecutionReportReject523( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)467; - } + ExecutionReportReject523(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportReject523(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + ExecutionReportReject523( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportReject523(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)523; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(483); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(523); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - ExecutionReportReject523 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportReject523( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } - ExecutionReportReject523 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + ExecutionReportReject523 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportReject523(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = ExecutionReportReject523( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + ExecutionReportReject523 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - ExecutionReportReject523 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportReject523( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = ExecutionReportReject523( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + ExecutionReportReject523 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportReject523(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + ExecutionReportReject523 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportReject523 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportReject523 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportReject523 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportReject523 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportReject523 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportReject523 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } + static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT + { + return 58; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= textSinceVersion(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 256; + } - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 256; + } - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportReject523 &text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } + ExecutionReportReject523 &text(const std::uint64_t index, const char value) + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } + std::uint64_t getText(char *const dst, const std::uint64_t length) const + { + if (length > 256) + { + throw std::runtime_error("length too large for getText [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportReject523 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } + ExecutionReportReject523 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); + return *this; + } - SBE_NODISCARD std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); + std::string getTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTextAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportReject523 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportReject523 &putText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - ExecutionReportReject523 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + return *this; + } + #else + ExecutionReportReject523 &putText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 268; + } - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportReject523 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } + ExecutionReportReject523 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportReject523 &putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 40); - return *this; - } + ExecutionReportReject523 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 40); + return *this; + } - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportReject523 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportReject523 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#else - ExecutionReportReject523 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + return *this; + } + #else + ExecutionReportReject523 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 308; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 308; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 308; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 308; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 308; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 308; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 308 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 308 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportReject523 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + ExecutionReportReject523 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 308 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 308 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 308, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 308, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportReject523 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 308, src, sizeof(char) * 20); - return *this; - } + ExecutionReportReject523 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 308, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 308; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 308; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 308; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 308; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportReject523 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportReject523 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 308 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 308 + start] = 0; + } - return *this; - } -#else - ExecutionReportReject523 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + ExecutionReportReject523 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 308 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 308 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 328; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 328; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 328; - } - - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 328; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 328; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 328; + } - char val; - std::memcpy(&val, m_buffer + m_offset + 328 + (index * 1), sizeof(char)); - return (val); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - ExecutionReportReject523 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 328 + (index * 1), sizeof(char)); + return (val); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 328 + (index * 1), &val, sizeof(char)); - return *this; - } + ExecutionReportReject523 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + char val = (value); + std::memcpy(m_buffer + m_offset + 328 + (index * 1), &val, sizeof(char)); + return *this; + } - std::memcpy( - dst, m_buffer + m_offset + 328, - sizeof(char) * static_cast(length)); - return length; - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - ExecutionReportReject523 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 328, src, sizeof(char) * 20); - return *this; - } + std::memcpy(dst, m_buffer + m_offset + 328, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 328; - size_t length = 0; + ExecutionReportReject523 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 328, src, sizeof(char) * 20); + return *this; + } - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 328; + std::size_t length = 0; - return result; - } + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + return result; + } - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 328; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 328; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportReject523 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportReject523 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 328 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 328 + start] = 0; + } - return *this; - } -#else - ExecutionReportReject523 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + ExecutionReportReject523 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 328 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 328 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 348; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 348; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportReject523 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportReject523 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 356; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 356; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 356, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 356, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportReject523 &orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 356, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportReject523 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 356, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceSinceVersion(); + return m_actingVersion >= priceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 364; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 364; + } - private: - PRICENULL9 m_price; +private: + PRICENULL9 m_price; - public: - SBE_NODISCARD PRICENULL9 &price() { - m_price.wrap(m_buffer, m_offset + 364, m_actingVersion, m_bufferLength); - return m_price; - } +public: + SBE_NODISCARD PRICENULL9 &price() + { + m_price.wrap(m_buffer, m_offset + 364, m_actingVersion, m_bufferLength); + return m_price; + } - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= stopPxSinceVersion(); + return m_actingVersion >= stopPxSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 372; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 372; + } - private: - PRICENULL9 m_stopPx; +private: + PRICENULL9 m_stopPx; - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 372, m_actingVersion, m_bufferLength); - return m_stopPx; - } +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 372, m_actingVersion, m_bufferLength); + return m_stopPx; + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transactTimeSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 380; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 380; + } - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 380, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 380, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportReject523 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 380, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportReject523 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 380, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 388; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 388; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 388, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 388, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportReject523 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 388, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportReject523 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 388, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 396; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 396; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 396, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 396, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportReject523 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 396, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportReject523 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 396, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT { return 548; } + static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT + { + return 548; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossIDSinceVersion(); + return m_actingVersion >= crossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossIDEncodingOffset() SBE_NOEXCEPT { - return 404; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossIDEncodingOffset() SBE_NOEXCEPT + { + return 404; + } - static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 404, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 404, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportReject523 &crossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 404, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportReject523 &crossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 404, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT { - return 961; - } + static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT + { + return 961; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hostCrossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hostCrossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hostCrossIDSinceVersion(); + return m_actingVersion >= hostCrossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hostCrossIDEncodingOffset() SBE_NOEXCEPT { - return 412; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hostCrossIDEncodingOffset() SBE_NOEXCEPT + { + return 412; + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 412, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 412, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportReject523 & - hostCrossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 412, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportReject523 &hostCrossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 412, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 420; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 420; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 420; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 420; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 420; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 420; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 420 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 420 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportReject523 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + ExecutionReportReject523 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 420 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 420 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 420, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 420, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportReject523 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 420, src, sizeof(char) * 5); - return *this; - } + ExecutionReportReject523 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 420, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 420; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 420; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 420; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 420; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportReject523 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportReject523 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 420, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 420 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 420, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 420 + start] = 0; + } - return *this; - } -#else - ExecutionReportReject523 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + ExecutionReportReject523 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 420, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 420 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 420, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 420 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 425; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 425; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 425, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 425, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportReject523 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 425, &val, sizeof(std::int32_t)); - return *this; - } + ExecutionReportReject523 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 425, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderQtySinceVersion(); + return m_actingVersion >= orderQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 429; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 429; + } - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 429, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 429, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportReject523 &orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 429, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportReject523 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 429, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT { return 110; } + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minQtySinceVersion(); + return m_actingVersion >= minQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minQtyEncodingOffset() SBE_NOEXCEPT { - return 433; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 433; + } - static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 433, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 433, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportReject523 &minQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 433, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportReject523 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 433, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT { - return 1138; - } + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayQtySinceVersion(); + return m_actingVersion >= displayQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayQtyEncodingOffset() SBE_NOEXCEPT { - return 437; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 437; + } - static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 437, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 437, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportReject523 & - displayQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 437, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportReject523 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 437, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordRejReasonId() SBE_NOEXCEPT { - return 103; - } + static SBE_CONSTEXPR std::uint16_t ordRejReasonId() SBE_NOEXCEPT + { + return 103; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordRejReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordRejReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordRejReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordRejReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordRejReasonSinceVersion(); + return m_actingVersion >= ordRejReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordRejReasonEncodingOffset() SBE_NOEXCEPT { - return 441; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordRejReasonEncodingOffset() SBE_NOEXCEPT + { + return 441; + } - static SBE_CONSTEXPR std::uint16_t ordRejReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t ordRejReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t ordRejReasonMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t ordRejReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t ordRejReasonMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t ordRejReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t ordRejReasonEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t ordRejReasonEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t ordRejReason() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 441, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t ordRejReason() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 441, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportReject523 & - ordRejReason(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 441, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportReject523 &ordRejReason(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 441, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= expireDateSinceVersion(); + return m_actingVersion >= expireDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 443; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 443; + } - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 443, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 443, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportReject523 & - expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 443, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportReject523 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 443, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 445; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 445; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 445, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 445, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportReject523 & - delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 445, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportReject523 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 445, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusSinceVersion(); + return m_actingVersion >= ordStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 447; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 447; + } - static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *ordStatus() const { - static const std::uint8_t ordStatusValues[] = {56}; + SBE_NODISCARD const char *ordStatus() const + { + static const std::uint8_t ordStatusValues[] = { 56, 0 }; - return (const char *)ordStatusValues; - } + return (const char *)ordStatusValues; + } - SBE_NODISCARD char ordStatus(const std::uint64_t index) const { - static const std::uint8_t ordStatusValues[] = {56}; + SBE_NODISCARD char ordStatus(const std::uint64_t index) const + { + static const std::uint8_t ordStatusValues[] = { 56, 0 }; - return (char)ordStatusValues[index]; - } + return (char)ordStatusValues[index]; + } - std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const { - static std::uint8_t ordStatusValues[] = {56}; - std::uint64_t bytesToCopy = - length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); + std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordStatusValues[] = { 56 }; + std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); - std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getOrdStatusAsString() const { - static const std::uint8_t OrdStatusValues[] = {56}; + std::string getOrdStatusAsString() const + { + static const std::uint8_t OrdStatusValues[] = { 56 }; - return std::string((const char *)OrdStatusValues, 1); - } + return std::string((const char *)OrdStatusValues, 1); + } - std::string getOrdStatusAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrdStatusAsString(); + std::string getOrdStatusAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrdStatusAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execTypeSinceVersion(); + return m_actingVersion >= execTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 447; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 447; + } - static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *execType() const { - static const std::uint8_t execTypeValues[] = {56}; + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 56, 0 }; - return (const char *)execTypeValues; - } + return (const char *)execTypeValues; + } - SBE_NODISCARD char execType(const std::uint64_t index) const { - static const std::uint8_t execTypeValues[] = {56}; + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 56, 0 }; - return (char)execTypeValues[index]; - } + return (char)execTypeValues[index]; + } - std::uint64_t getExecType(char *dst, const std::uint64_t length) const { - static std::uint8_t execTypeValues[] = {56}; - std::uint64_t bytesToCopy = - length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 56 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); - std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getExecTypeAsString() const { - static const std::uint8_t ExecTypeValues[] = {56}; + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 56 }; - return std::string((const char *)ExecTypeValues, 1); - } + return std::string((const char *)ExecTypeValues, 1); + } - std::string getExecTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecTypeAsString(); + std::string getExecTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 447; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 447; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 447, sizeof(char)); - return OrderType::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 447, sizeof(char)); + return (val); + } - ExecutionReportReject523 & - ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 447, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 447, sizeof(char)); + return OrderType::get((val)); + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportReject523 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 447, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 448; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 448; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 448, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 448, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportReject523 &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 448, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 448, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportReject523 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 448, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 449; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 449; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 449, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 449, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportReject523 & - timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 449, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 449, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportReject523 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 449, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 450; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 450; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 450, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 450, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportReject523 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 450, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 450, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportReject523 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 450, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 451; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 451; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 451, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 451, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportReject523 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 451, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 451, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportReject523 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 451, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 452; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 452; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 452, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 452, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportReject523 & - splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 452, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 452, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char * - CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportReject523 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 452, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT { return 549; } + SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT + { + return 549; + } - SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossTypeSinceVersion(); + return m_actingVersion >= crossTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossTypeEncodingOffset() SBE_NOEXCEPT { - return 453; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossTypeEncodingOffset() SBE_NOEXCEPT + { + return 453; + } - static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 453, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 453, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportReject523 &crossType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 453, &val, sizeof(std::uint8_t)); - return *this; - } + ExecutionReportReject523 &crossType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 453, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execInstSinceVersion(); + return m_actingVersion >= execInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 454; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 454; + } - private: - ExecInst m_execInst; +private: + ExecInst m_execInst; - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 454, m_actingVersion, m_bufferLength); - return m_execInst; - } +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 454, m_actingVersion, m_bufferLength); + return m_execInst; + } - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executionModeSinceVersion(); + return m_actingVersion >= executionModeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 455; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 455; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 455, sizeof(char)); - return ExecMode::get((val)); - } + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 455, sizeof(char)); + return (val); + } - ExecutionReportReject523 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 455, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 455, sizeof(char)); + return ExecMode::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportReject523 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 455, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 456; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 456; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 456, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 456, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportReject523 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 456, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 456, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportReject523 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 456, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= managedOrderSinceVersion(); + return m_actingVersion >= managedOrderSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 457; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 457; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 457, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 457, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportReject523 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 457, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 457, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportReject523 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 457, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= shortSaleTypeSinceVersion(); + return m_actingVersion >= shortSaleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 458; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 458; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 458, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 458, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportReject523 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 458, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 458, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportReject523 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 458, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 459; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 459; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return 0xffffffffffffffffL; - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return UINT64_C(0xffffffffffffffff); + } - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 459, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 459, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportReject523 & - delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 459, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportReject523 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 459, &val, sizeof(std::uint64_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportReject523 _writer) { - ExecutionReportReject523 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportReject523", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 467; + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; +private: + PRICENULL9 m_discretionPrice; - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 467, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + SBE_NODISCARD static const char *ReservationPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + static SBE_CONSTEXPR std::uint16_t reservationPriceId() SBE_NOEXCEPT + { + return 9562; + } - builder << ", "; - builder << R"("Price": )"; - builder << writer.price(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reservationPriceSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); + SBE_NODISCARD bool reservationPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reservationPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reservationPriceEncodingOffset() SBE_NOEXCEPT + { + return 475; + } - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); +private: + PRICENULL9 m_reservationPrice; - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); +public: + SBE_NODISCARD PRICENULL9 &reservationPrice() + { + m_reservationPrice.wrap(m_buffer, m_offset + 475, m_actingVersion, m_bufferLength); + return m_reservationPrice; + } - builder << ", "; - builder << R"("CrossID": )"; - builder << +writer.crossID(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportReject523 _writer) +{ + ExecutionReportReject523 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("HostCrossID": )"; - builder << +writer.hostCrossID(); + builder << '{'; + builder << R"("Name": "ExecutionReportReject523", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); + builder << ", "; + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("MinQty": )"; - builder << +writer.minQty(); + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("DisplayQty": )"; - builder << +writer.displayQty(); + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("OrdRejReason": )"; - builder << +writer.ordRejReason(); + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("CrossID": )"; + builder << +writer.crossID(); - builder << ", "; - builder << R"("CrossType": )"; - builder << +writer.crossType(); + builder << ", "; + builder << R"("HostCrossID": )"; + builder << +writer.hostCrossID(); - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); + builder << ", "; + builder << R"("OrdRejReason": )"; + builder << +writer.ordRejReason(); - builder << '}'; + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); - return builder; - } + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); - void skip() {} + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + builder << R"("CrossType": )"; + builder << +writer.crossType(); + + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); + + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("ReservationPrice": )"; + if (writer.reservationPriceInActingVersion()) + { + builder << writer.reservationPrice(); + } + else + { + builder << "{}"; + } + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportStatus532.h b/src/lib/orderman/ilink3/generated/ExecutionReportStatus532.h index 2631dd535..20c2a4399 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportStatus532.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportStatus532.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3454 +86,4476 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportStatus532 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class ExecutionReportStatus532 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(513); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(532); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - ExecutionReportStatus532() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - ExecutionReportStatus532( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - ExecutionReportStatus532(char *buffer, const std::uint64_t bufferLength) - : ExecutionReportStatus532( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + ExecutionReportStatus532() = default; - ExecutionReportStatus532( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportStatus532( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + ExecutionReportStatus532( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)480; - } + ExecutionReportStatus532(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportStatus532(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + ExecutionReportStatus532( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportStatus532(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)532; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(513); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(532); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - ExecutionReportStatus532 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportStatus532( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } - ExecutionReportStatus532 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + ExecutionReportStatus532 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportStatus532(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = ExecutionReportStatus532( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + ExecutionReportStatus532 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - ExecutionReportStatus532 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportStatus532( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = ExecutionReportStatus532( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + ExecutionReportStatus532 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportStatus532(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + ExecutionReportStatus532 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportStatus532 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportStatus532 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportStatus532 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportStatus532 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } + static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT + { + return 58; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= textSinceVersion(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 256; + } - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 256; + } - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportStatus532 &text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } + ExecutionReportStatus532 &text(const std::uint64_t index, const char value) + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } + std::uint64_t getText(char *const dst, const std::uint64_t length) const + { + if (length > 256) + { + throw std::runtime_error("length too large for getText [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportStatus532 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } + ExecutionReportStatus532 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); + return *this; + } - SBE_NODISCARD std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); + std::string getTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTextAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportStatus532 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportStatus532 &putText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - ExecutionReportStatus532 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + return *this; + } + #else + ExecutionReportStatus532 &putText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 268; + } - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportStatus532 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } + ExecutionReportStatus532 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportStatus532 &putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 40); - return *this; - } + ExecutionReportStatus532 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 40); + return *this; + } - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportStatus532 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportStatus532 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#else - ExecutionReportStatus532 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + return *this; + } + #else + ExecutionReportStatus532 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 308; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 308; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 308; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 308; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 308; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 308; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 308 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 308 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportStatus532 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + ExecutionReportStatus532 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 308 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 308 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 308, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 308, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportStatus532 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 308, src, sizeof(char) * 20); - return *this; - } + ExecutionReportStatus532 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 308, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 308; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 308; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 308; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 308; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportStatus532 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportStatus532 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 308 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 308 + start] = 0; + } - return *this; - } -#else - ExecutionReportStatus532 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + ExecutionReportStatus532 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 308 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 308 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 328; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 328; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 328; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 328; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 328; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 328; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 328 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 328 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportStatus532 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + ExecutionReportStatus532 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 328 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 328 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 328, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 328, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportStatus532 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 328, src, sizeof(char) * 20); - return *this; - } + ExecutionReportStatus532 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 328, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 328; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 328; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 328; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 328; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportStatus532 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportStatus532 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 328 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 328 + start] = 0; + } - return *this; - } -#else - ExecutionReportStatus532 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + ExecutionReportStatus532 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 328 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 328 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 348; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 348; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 356; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 356; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 356, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 356, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 &orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 356, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 356, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceSinceVersion(); + return m_actingVersion >= priceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 364; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 364; + } - private: - PRICENULL9 m_price; +private: + PRICENULL9 m_price; - public: - SBE_NODISCARD PRICENULL9 &price() { - m_price.wrap(m_buffer, m_offset + 364, m_actingVersion, m_bufferLength); - return m_price; - } +public: + SBE_NODISCARD PRICENULL9 &price() + { + m_price.wrap(m_buffer, m_offset + 364, m_actingVersion, m_bufferLength); + return m_price; + } - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= stopPxSinceVersion(); + return m_actingVersion >= stopPxSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 372; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 372; + } - private: - PRICENULL9 m_stopPx; +private: + PRICENULL9 m_stopPx; - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 372, m_actingVersion, m_bufferLength); - return m_stopPx; - } +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 372, m_actingVersion, m_bufferLength); + return m_stopPx; + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transactTimeSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 380; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 380; + } - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 380, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 380, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 380, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 380, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 388; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 388; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 388, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 388, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 388, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 388, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 396; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 396; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 396, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 396, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 396, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 396, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusReqIDId() SBE_NOEXCEPT { - return 790; - } + static SBE_CONSTEXPR std::uint16_t ordStatusReqIDId() SBE_NOEXCEPT + { + return 790; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusReqIDSinceVersion(); + return m_actingVersion >= ordStatusReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusReqIDEncodingOffset() SBE_NOEXCEPT { - return 404; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusReqIDEncodingOffset() SBE_NOEXCEPT + { + return 404; + } - static SBE_CONSTEXPR std::uint64_t ordStatusReqIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t ordStatusReqIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - ordStatusReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t ordStatusReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t ordStatusReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 404, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t ordStatusReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 404, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 & - ordStatusReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 404, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &ordStatusReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 404, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *MassStatusReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massStatusReqIDId() SBE_NOEXCEPT { - return 584; - } + static SBE_CONSTEXPR std::uint16_t massStatusReqIDId() SBE_NOEXCEPT + { + return 584; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massStatusReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massStatusReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massStatusReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massStatusReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massStatusReqIDSinceVersion(); + return m_actingVersion >= massStatusReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massStatusReqIDEncodingOffset() SBE_NOEXCEPT { - return 412; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massStatusReqIDEncodingOffset() SBE_NOEXCEPT + { + return 412; + } - static SBE_CONSTEXPR std::uint64_t massStatusReqIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t massStatusReqIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t massStatusReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t massStatusReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t massStatusReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t massStatusReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - massStatusReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t massStatusReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t massStatusReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 412, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t massStatusReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 412, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 & - massStatusReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 412, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &massStatusReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 412, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT { return 548; } + static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT + { + return 548; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossIDSinceVersion(); + return m_actingVersion >= crossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossIDEncodingOffset() SBE_NOEXCEPT { - return 420; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossIDEncodingOffset() SBE_NOEXCEPT + { + return 420; + } - static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 420, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 420, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 &crossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 420, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &crossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 420, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT { - return 961; - } + static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT + { + return 961; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hostCrossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hostCrossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hostCrossIDSinceVersion(); + return m_actingVersion >= hostCrossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hostCrossIDEncodingOffset() SBE_NOEXCEPT { - return 428; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hostCrossIDEncodingOffset() SBE_NOEXCEPT + { + return 428; + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 428, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 428, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ExecutionReportStatus532 & - hostCrossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 428, &val, sizeof(std::uint64_t)); - return *this; - } + ExecutionReportStatus532 &hostCrossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 428, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 436; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 436; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 436; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 436; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 436; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 436; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 436 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 436 + (index * 1), sizeof(char)); + return (val); + } - ExecutionReportStatus532 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + ExecutionReportStatus532 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 436 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 436 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 436, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 436, sizeof(char) * static_cast(length)); + return length; + } - ExecutionReportStatus532 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 436, src, sizeof(char) * 5); - return *this; - } + ExecutionReportStatus532 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 436, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 436; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 436; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 436; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 436; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - ExecutionReportStatus532 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportStatus532 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 436, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 436 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 436, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 436 + start] = 0; + } - return *this; - } -#else - ExecutionReportStatus532 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + ExecutionReportStatus532 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 436, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 436 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 436, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 436 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 441; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 441; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 441, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 441, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportStatus532 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 441, &val, sizeof(std::int32_t)); - return *this; - } + ExecutionReportStatus532 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 441, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderQtySinceVersion(); + return m_actingVersion >= orderQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 445; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 445; + } - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 445, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 445, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportStatus532 &orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 445, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportStatus532 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 445, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT { return 14; } + static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cumQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cumQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cumQtySinceVersion(); + return m_actingVersion >= cumQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cumQtyEncodingOffset() SBE_NOEXCEPT { - return 449; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cumQtyEncodingOffset() SBE_NOEXCEPT + { + return 449; + } - static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 449, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 449, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportStatus532 &cumQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 449, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportStatus532 &cumQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 449, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT { return 151; } + static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT + { + return 151; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - leavesQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t leavesQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= leavesQtySinceVersion(); + return m_actingVersion >= leavesQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - leavesQtyEncodingOffset() SBE_NOEXCEPT { - return 453; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t leavesQtyEncodingOffset() SBE_NOEXCEPT + { + return 453; + } - static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 453, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 453, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportStatus532 &leavesQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 453, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportStatus532 &leavesQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 453, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT { return 110; } + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minQtySinceVersion(); + return m_actingVersion >= minQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minQtyEncodingOffset() SBE_NOEXCEPT { - return 457; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 457; + } - static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 457, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 457, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportStatus532 &minQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 457, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportStatus532 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 457, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT { - return 1138; - } + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayQtySinceVersion(); + return m_actingVersion >= displayQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayQtyEncodingOffset() SBE_NOEXCEPT { - return 461; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 461; + } - static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 461, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 461, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - ExecutionReportStatus532 & - displayQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 461, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportStatus532 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 461, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= expireDateSinceVersion(); + return m_actingVersion >= expireDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 465; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 465; + } - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 465, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 465, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - ExecutionReportStatus532 & - expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 465, &val, sizeof(std::uint16_t)); - return *this; - } + ExecutionReportStatus532 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 465, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusSinceVersion(); + return m_actingVersion >= ordStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 467; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 467; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OrderStatus::Value ordStatus() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 467, sizeof(char)); - return OrderStatus::get((val)); - } + SBE_NODISCARD char ordStatusRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 467, sizeof(char)); + return (val); + } - ExecutionReportStatus532 & - ordStatus(const OrderStatus::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 467, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD OrderStatus::Value ordStatus() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 467, sizeof(char)); + return OrderStatus::get((val)); + } - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + ExecutionReportStatus532 &ordStatus(const OrderStatus::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 467, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execTypeSinceVersion(); + return m_actingVersion >= execTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 468; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 468; + } - static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *execType() const { - static const std::uint8_t execTypeValues[] = {73}; + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 73, 0 }; - return (const char *)execTypeValues; - } + return (const char *)execTypeValues; + } - SBE_NODISCARD char execType(const std::uint64_t index) const { - static const std::uint8_t execTypeValues[] = {73}; + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 73, 0 }; - return (char)execTypeValues[index]; - } + return (char)execTypeValues[index]; + } - std::uint64_t getExecType(char *dst, const std::uint64_t length) const { - static std::uint8_t execTypeValues[] = {73}; - std::uint64_t bytesToCopy = - length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 73 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); - std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getExecTypeAsString() const { - static const std::uint8_t ExecTypeValues[] = {73}; + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 73 }; - return std::string((const char *)ExecTypeValues, 1); - } + return std::string((const char *)ExecTypeValues, 1); + } - std::string getExecTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecTypeAsString(); + std::string getExecTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 468; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 468; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 468, sizeof(char)); - return OrderType::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 468, sizeof(char)); + return (val); + } - ExecutionReportStatus532 & - ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 468, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 468, sizeof(char)); + return OrderType::get((val)); + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportStatus532 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 468, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 469; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 469; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 469, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 469, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportStatus532 &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 469, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 469, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportStatus532 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 469, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 470; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 470; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 470, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 470, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportStatus532 & - timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 470, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 470, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportStatus532 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 470, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 471; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 471; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 471, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 471, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportStatus532 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 471, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 471, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportStatus532 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 471, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 472; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 472; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 472, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 472, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportStatus532 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 472, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 472, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char *LastRptRequestedMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportStatus532 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 472, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t lastRptRequestedId() SBE_NOEXCEPT { - return 912; - } + SBE_NODISCARD static const char *LastRptRequestedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastRptRequestedSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t lastRptRequestedId() SBE_NOEXCEPT + { + return 912; + } - SBE_NODISCARD bool lastRptRequestedInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastRptRequestedSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastRptRequestedInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastRptRequestedSinceVersion(); + return m_actingVersion >= lastRptRequestedSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastRptRequestedEncodingOffset() SBE_NOEXCEPT { - return 473; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastRptRequestedEncodingOffset() SBE_NOEXCEPT + { + return 473; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastRptRequestedEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastRptRequestedEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value lastRptRequested() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 473, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t lastRptRequestedRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 473, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportStatus532 & - lastRptRequested(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 473, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value lastRptRequested() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 473, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + ExecutionReportStatus532 &lastRptRequested(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 473, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT { return 549; } + SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT + { + return 549; + } - SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossTypeSinceVersion(); + return m_actingVersion >= crossTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossTypeEncodingOffset() SBE_NOEXCEPT { - return 474; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossTypeEncodingOffset() SBE_NOEXCEPT + { + return 474; + } - static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 474, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 474, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportStatus532 &crossType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 474, &val, sizeof(std::uint8_t)); - return *this; - } + ExecutionReportStatus532 &crossType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 474, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execInstSinceVersion(); + return m_actingVersion >= execInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 475; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 475; + } - private: - ExecInst m_execInst; +private: + ExecInst m_execInst; - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 475, m_actingVersion, m_bufferLength); - return m_execInst; - } +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 475, m_actingVersion, m_bufferLength); + return m_execInst; + } - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executionModeSinceVersion(); + return m_actingVersion >= executionModeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 476; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 476; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 476, sizeof(char)); - return ExecMode::get((val)); - } + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 476, sizeof(char)); + return (val); + } - ExecutionReportStatus532 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 476, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 476, sizeof(char)); + return ExecMode::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportStatus532 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 476, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 477; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 477; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 477, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 477, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportStatus532 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 477, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 477, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportStatus532 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 477, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= managedOrderSinceVersion(); + return m_actingVersion >= managedOrderSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 478; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 478; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 478, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 478, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportStatus532 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 478, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 478, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + ExecutionReportStatus532 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 478, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= shortSaleTypeSinceVersion(); + return m_actingVersion >= shortSaleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 479; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 479; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 479, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 479, sizeof(std::uint8_t)); + return (val); + } - ExecutionReportStatus532 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 479, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 479, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportStatus532 _writer) { - ExecutionReportStatus532 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportStatus532", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + ExecutionReportStatus532 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 479, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 480; + } - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; +private: + PRICENULL9 m_discretionPrice; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 480, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + SBE_NODISCARD static const char *ReservationPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("Price": )"; - builder << writer.price(); + static SBE_CONSTEXPR std::uint16_t reservationPriceId() SBE_NOEXCEPT + { + return 9562; + } - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reservationPriceSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + SBE_NODISCARD bool reservationPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reservationPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reservationPriceEncodingOffset() SBE_NOEXCEPT + { + return 488; + } - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); +private: + PRICENULL9 m_reservationPrice; - builder << ", "; - builder << R"("OrdStatusReqID": )"; - builder << +writer.ordStatusReqID(); +public: + SBE_NODISCARD PRICENULL9 &reservationPrice() + { + m_reservationPrice.wrap(m_buffer, m_offset + 488, m_actingVersion, m_bufferLength); + return m_reservationPrice; + } - builder << ", "; - builder << R"("MassStatusReqID": )"; - builder << +writer.massStatusReqID(); + SBE_NODISCARD static const char *PriorityIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - builder << ", "; - builder << R"("CrossID": )"; - builder << +writer.crossID(); + static SBE_CONSTEXPR std::uint16_t priorityIndicatorId() SBE_NOEXCEPT + { + return 638; + } - builder << ", "; - builder << R"("HostCrossID": )"; - builder << +writer.hostCrossID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priorityIndicatorSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD bool priorityIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priorityIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 496; + } - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - builder << ", "; - builder << R"("CumQty": )"; - builder << +writer.cumQty(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - builder << ", "; - builder << R"("LeavesQty": )"; - builder << +writer.leavesQty(); + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - builder << ", "; - builder << R"("MinQty": )"; - builder << +writer.minQty(); + static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - builder << ", "; - builder << R"("DisplayQty": )"; - builder << +writer.displayQty(); + SBE_NODISCARD std::uint8_t priorityIndicator() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 496, sizeof(std::uint8_t)); + return (val); + } - builder << ", "; - builder << R"("OrdStatus": )"; - builder << '"' << writer.ordStatus() << '"'; + ExecutionReportStatus532 &priorityIndicator(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 496, &val, sizeof(std::uint8_t)); + return *this; + } - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + SBE_NODISCARD static const char *OrigOrderUserMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + static SBE_CONSTEXPR std::uint16_t origOrderUserId() SBE_NOEXCEPT + { + return 9937; + } - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origOrderUserSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + SBE_NODISCARD bool origOrderUserInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origOrderUserSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origOrderUserEncodingOffset() SBE_NOEXCEPT + { + return 497; + } - builder << ", "; - builder << R"("LastRptRequested": )"; - builder << '"' << writer.lastRptRequested() << '"'; + static SBE_CONSTEXPR char origOrderUserNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - builder << ", "; - builder << R"("CrossType": )"; - builder << +writer.crossType(); + static SBE_CONSTEXPR char origOrderUserMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + static SBE_CONSTEXPR char origOrderUserMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + static SBE_CONSTEXPR std::size_t origOrderUserEncodingLength() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + static SBE_CONSTEXPR std::uint64_t origOrderUserLength() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + SBE_NODISCARD const char *origOrderUser() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + return m_buffer + m_offset + 497; + } - builder << '}'; + SBE_NODISCARD char *origOrderUser() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } - return builder; - } + return m_buffer + m_offset + 497; + } - void skip() {} + SBE_NODISCARD char origOrderUser(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E104]"); + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + if (m_actingVersion < 8) + { + return static_cast(0); + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + char val; + std::memcpy(&val, m_buffer + m_offset + 497 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportStatus532 &origOrderUser(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 497 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrigOrderUser(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getOrigOrderUser [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 497, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportStatus532 &putOrigOrderUser(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 497, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getOrigOrderUserAsString() const + { + const char *buffer = m_buffer + m_offset + 497; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrigOrderUserAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrigOrderUserAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrigOrderUserAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 497; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportStatus532 &putOrigOrderUser(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 497, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 497 + start] = 0; + } + + return *this; + } + #else + ExecutionReportStatus532 &putOrigOrderUser(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 497, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 497 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *CancelTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cancelTextId() SBE_NOEXCEPT + { + return 2807; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cancelTextSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool cancelTextInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cancelTextSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cancelTextEncodingOffset() SBE_NOEXCEPT + { + return 505; + } + + static SBE_CONSTEXPR char cancelTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char cancelTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char cancelTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t cancelTextEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t cancelTextLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *cancelText() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 505; + } + + SBE_NODISCARD char *cancelText() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 505; + } + + SBE_NODISCARD char cancelText(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 505 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportStatus532 &cancelText(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 505 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getCancelText(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getCancelText [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 505, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportStatus532 &putCancelText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 505, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getCancelTextAsString() const + { + const char *buffer = m_buffer + m_offset + 505; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getCancelTextAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getCancelTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCancelTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 505; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportStatus532 &putCancelText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 505, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 505 + start] = 0; + } + + return *this; + } + #else + ExecutionReportStatus532 &putCancelText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 505, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 505 + start] = 0; + } + + return *this; + } + #endif + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportStatus532 _writer) +{ + ExecutionReportStatus532 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "ExecutionReportStatus532", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); + + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("OrdStatusReqID": )"; + builder << +writer.ordStatusReqID(); + + builder << ", "; + builder << R"("MassStatusReqID": )"; + builder << +writer.massStatusReqID(); + + builder << ", "; + builder << R"("CrossID": )"; + builder << +writer.crossID(); + + builder << ", "; + builder << R"("HostCrossID": )"; + builder << +writer.hostCrossID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("CumQty": )"; + builder << +writer.cumQty(); + + builder << ", "; + builder << R"("LeavesQty": )"; + builder << +writer.leavesQty(); + + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); + + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); + + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); + + builder << ", "; + builder << R"("OrdStatus": )"; + builder << '"' << writer.ordStatus() << '"'; + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("LastRptRequested": )"; + builder << '"' << writer.lastRptRequested() << '"'; + + builder << ", "; + builder << R"("CrossType": )"; + builder << +writer.crossType(); + + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("ReservationPrice": )"; + if (writer.reservationPriceInActingVersion()) + { + builder << writer.reservationPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("PriorityIndicator": )"; + builder << +writer.priorityIndicator(); + + builder << ", "; + builder << R"("OrigOrderUser": )"; + builder << '"' << + writer.getOrigOrderUserAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("CancelText": )"; + builder << '"' << + writer.getCancelTextAsJsonEscapedString().c_str() << '"'; + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumOutright548.h b/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumOutright548.h index 2cf076cf4..1070778b1 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumOutright548.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumOutright548.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,4064 +86,5050 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportTradeAddendumOutright548 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - ExecutionReportTradeAddendumOutright548() = default; - - ExecutionReportTradeAddendumOutright548( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - ExecutionReportTradeAddendumOutright548( - char *buffer, const std::uint64_t bufferLength) - : ExecutionReportTradeAddendumOutright548( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - ExecutionReportTradeAddendumOutright548( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportTradeAddendumOutright548( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)181; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)548; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - ExecutionReportTradeAddendumOutright548 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeAddendumOutright548( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - ExecutionReportTradeAddendumOutright548 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = ExecutionReportTradeAddendumOutright548( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - ExecutionReportTradeAddendumOutright548 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeAddendumOutright548( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportTradeAddendumOutright548 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumOutright548 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= uUIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumOutright548 & - uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } - - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } - - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumOutright548 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumOutright548 & - putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } - - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumOutright548 & - putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumOutright548 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumOutright548 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumOutright548 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumOutright548 & - putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumOutright548 & - putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= clOrdIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } - - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumOutright548 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumOutright548 & - putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumOutright548 & - putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumOutright548 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 92; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumOutright548 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT { return 31; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastPxEncodingOffset() SBE_NOEXCEPT { - return 100; - } - - private: - PRICE9 m_lastPx; - - public: - SBE_NODISCARD PRICE9 &lastPx() { - m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); - return m_lastPx; - } - - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 108; - } - - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumOutright548 & - orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= transactTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 116; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumOutright548 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 124; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumOutright548 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT { return 527; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - secExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= secExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - secExecIDEncodingOffset() SBE_NOEXCEPT { - return 132; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumOutright548 & - secExecID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *OrigSecondaryExecutionIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - origSecondaryExecutionIDId() SBE_NOEXCEPT { - return 9703; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool origSecondaryExecutionIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= origSecondaryExecutionIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - origSecondaryExecutionIDEncodingOffset() SBE_NOEXCEPT { - return 140; - } - - static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - origSecondaryExecutionIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t origSecondaryExecutionID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumOutright548 & - origSecondaryExecutionID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 148; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 148; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 148; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 148 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumOutright548 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 148 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 148, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumOutright548 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 148, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 148; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 148; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumOutright548 & - putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 148, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 148 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumOutright548 & - putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 148, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 148 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 153; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 153, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumOutright548 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 153, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT { return 32; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastQtyEncodingOffset() SBE_NOEXCEPT { - return 157; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumOutright548 & - lastQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT { - return 1506; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideTradeIDEncodingOffset() SBE_NOEXCEPT { - return 161; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumOutright548 & - sideTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrigSideTradeIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t origSideTradeIDId() SBE_NOEXCEPT { - return 1507; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - origSideTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool origSideTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= origSideTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - origSideTradeIDEncodingOffset() SBE_NOEXCEPT { - return 165; - } - - static SBE_CONSTEXPR std::uint32_t origSideTradeIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t origSideTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t origSideTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - origSideTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t origSideTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 165, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumOutright548 & - origSideTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 165, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT { return 75; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradeDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradeDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeDateEncodingOffset() SBE_NOEXCEPT { - return 169; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - ExecutionReportTradeAddendumOutright548 & - tradeDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordStatusSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 171; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrdStatusTrdCxl::Value ordStatus() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); - return OrdStatusTrdCxl::get((val)); - } - - ExecutionReportTradeAddendumOutright548 & - ordStatus(const OrdStatusTrdCxl::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 171, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 172; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ExecTypTrdCxl::Value execType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 172, sizeof(char)); - return ExecTypTrdCxl::get((val)); - } - - ExecutionReportTradeAddendumOutright548 & - execType(const ExecTypTrdCxl::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 172, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 173; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); - return SideReq::get((val)); - } - - ExecutionReportTradeAddendumOutright548 & - side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 174; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - ExecutionReportTradeAddendumOutright548 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 174, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= possRetransFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 175; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - ExecutionReportTradeAddendumOutright548 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 175, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execInstSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 176; - } - - private: - ExecInst m_execInst; - - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 176, m_actingVersion, m_bufferLength); - return m_execInst; - } - - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= executionModeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 177; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 177, sizeof(char)); - return ExecMode::get((val)); - } - - ExecutionReportTradeAddendumOutright548 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 177, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= liquidityFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 178; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 178, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - ExecutionReportTradeAddendumOutright548 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 178, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= managedOrderSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 179; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 179, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - ExecutionReportTradeAddendumOutright548 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 179, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= shortSaleTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 180; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 180, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } - - ExecutionReportTradeAddendumOutright548 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 180, &val, sizeof(std::uint8_t)); - return *this; - } - - class NoFills { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)15); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 15; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 15; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { +class ExecutionReportTradeAddendumOutright548 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(222); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(548); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + ExecutionReportTradeAddendumOutright548() = default; + + ExecutionReportTradeAddendumOutright548( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + ExecutionReportTradeAddendumOutright548(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportTradeAddendumOutright548(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + ExecutionReportTradeAddendumOutright548( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportTradeAddendumOutright548(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(222); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(548); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + ExecutionReportTradeAddendumOutright548 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeAddendumOutright548(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + ExecutionReportTradeAddendumOutright548 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = ExecutionReportTradeAddendumOutright548( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + ExecutionReportTradeAddendumOutright548 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeAddendumOutright548(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + ExecutionReportTradeAddendumOutright548 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + } + return position; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportTradeAddendumOutright548 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoFills &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - return *this; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD static const char * - FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT { - return 1364; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillPxSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICE9 m_fillPx; + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - public: - SBE_NODISCARD PRICE9 &fillPx() { - m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_fillPx; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - SBE_NODISCARD static const char * - FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT { - return 1365; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT { + ExecutionReportTradeAddendumOutright548 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillQtySinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportTradeAddendumOutright548 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT { - return 1363; - } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillExecIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillExecIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char fillExecID(const std::uint64_t index) const { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy( - &val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - NoFills &fillExecID(const std::uint64_t index, const char value) { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E105]"); - } + ExecutionReportTradeAddendumOutright548 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy( - m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getFillExecID(char *const dst, const std::uint64_t length) const { - if (length > 2) { - throw std::runtime_error( - "length too large for getFillExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); - return *this; - } + ExecutionReportTradeAddendumOutright548 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - NoFills & - putFillExecID(const char value0, const char value1) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - return *this; - } + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - SBE_NODISCARD std::string getFillExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + return result; + } - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - return result; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - std::string getFillExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getFillExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getFillExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NoFills &putFillExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumOutright548 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#else - NoFills &putFillExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + return *this; + } + #else + ExecutionReportTradeAddendumOutright548 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *FillYieldTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT { - return 1622; - } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillYieldTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillYieldTypeSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return (val); - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoFills writer) { - builder << '{'; - builder << R"("FillPx": )"; - builder << writer.fillPx(); + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - builder << ", "; - builder << R"("FillQty": )"; - builder << +writer.fillQty(); + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - builder << ", "; - builder << R"("FillExecID": )"; - builder << '"' << writer.getFillExecIDAsJsonEscapedString().c_str() - << '"'; + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - builder << ", "; - builder << R"("FillYieldType": )"; - builder << +writer.fillYieldType(); + ExecutionReportTradeAddendumOutright548 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - builder << '}'; + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - return builder; - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - void skip() {} + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + ExecutionReportTradeAddendumOutright548 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - private: - NoFills m_noFills; + return result; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT { - return 1362; - } + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - SBE_NODISCARD inline NoFills &noFills() { - m_noFills.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - NoFills &noFillsCount(const std::uint8_t count) { - m_noFills.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noFillsSinceVersion() SBE_NOEXCEPT { - return 0; - } + return oss.str(); + } - SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT { + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumOutright548 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeAddendumOutright548 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noFillsSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoOrderEvents { + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } + + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeAddendumOutright548 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeAddendumOutright548 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumOutright548 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeAddendumOutright548 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumOutright548 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT + { + return 31; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastPxSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastPxEncodingOffset() SBE_NOEXCEPT + { + return 100; + } + +private: + PRICE9 m_lastPx; + +public: + SBE_NODISCARD PRICE9 &lastPx() + { + m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); + return m_lastPx; + } + + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 108; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumOutright548 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= transactTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 116; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumOutright548 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 124; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumOutright548 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT + { + return 527; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t secExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= secExecIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t secExecIDEncodingOffset() SBE_NOEXCEPT + { + return 132; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumOutright548 &secExecID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrigSecondaryExecutionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origSecondaryExecutionIDId() SBE_NOEXCEPT + { + return 9703; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool origSecondaryExecutionIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origSecondaryExecutionIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origSecondaryExecutionIDEncodingOffset() SBE_NOEXCEPT + { + return 140; + } + + static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t origSecondaryExecutionIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t origSecondaryExecutionID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumOutright548 &origSecondaryExecutionID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 148; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 148; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 148; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 148 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeAddendumOutright548 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 148 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 148, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeAddendumOutright548 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 148, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 148; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 148; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumOutright548 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 148, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 148 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeAddendumOutright548 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 148, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 148 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 153; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 153, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumOutright548 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 153, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT + { + return 32; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastQtyEncodingOffset() SBE_NOEXCEPT + { + return 157; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumOutright548 &lastQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT + { + return 1506; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideTradeIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 161; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumOutright548 &sideTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrigSideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origSideTradeIDId() SBE_NOEXCEPT + { + return 1507; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origSideTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool origSideTradeIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origSideTradeIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origSideTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 165; + } + + static SBE_CONSTEXPR std::uint32_t origSideTradeIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t origSideTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t origSideTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t origSideTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t origSideTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 165, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumOutright548 &origSideTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 165, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT + { + return 75; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradeDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= tradeDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeDateEncodingOffset() SBE_NOEXCEPT + { + return 169; + } + + static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeAddendumOutright548 &tradeDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordStatusSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 171; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char ordStatusRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); + return (val); + } + + SBE_NODISCARD OrdStatusTrdCxl::Value ordStatus() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); + return OrdStatusTrdCxl::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &ordStatus(const OrdStatusTrdCxl::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 171, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 172; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char execTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(char)); + return (val); + } + + SBE_NODISCARD ExecTypTrdCxl::Value execType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(char)); + return ExecTypTrdCxl::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &execType(const ExecTypTrdCxl::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 172, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 173; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= manualOrderIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 174; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 174, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= possRetransFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 175; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 175, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execInstSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 176; + } + +private: + ExecInst m_execInst; + +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 176, m_actingVersion, m_bufferLength); + return m_execInst; + } + + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= executionModeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 177; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(char)); + return (val); + } + + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(char)); + return ExecMode::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 177, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= liquidityFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 178; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 178, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 178, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 178, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= managedOrderSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 179; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 179, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 179, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 179, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= shortSaleTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 180; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 180, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 180, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 180, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 181; + } + +private: + PRICENULL9 m_discretionPrice; + +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 181, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } + + SBE_NODISCARD static const char *TrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t trdTypeId() SBE_NOEXCEPT + { + return 828; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t trdTypeSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool trdTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= trdTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t trdTypeEncodingOffset() SBE_NOEXCEPT + { + return 189; + } + + static SBE_CONSTEXPR std::uint16_t trdTypeNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t trdTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t trdTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t trdTypeEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t trdType() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } + + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeAddendumOutright548 &trdType(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecRestatementReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execRestatementReasonId() SBE_NOEXCEPT + { + return 378; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execRestatementReasonSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool execRestatementReasonInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execRestatementReasonSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execRestatementReasonEncodingOffset() SBE_NOEXCEPT + { + return 191; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execRestatementReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t execRestatementReasonRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ExecReason::Value execRestatementReason() const + { + if (m_actingVersion < 6) + { + return ExecReason::NULL_VALUE; + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint8_t)); + return ExecReason::get((val)); + } + + ExecutionReportTradeAddendumOutright548 &execRestatementReason(const ExecReason::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 191, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SettlDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t settlDateId() SBE_NOEXCEPT + { + return 64; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlDateSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool settlDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= settlDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlDateEncodingOffset() SBE_NOEXCEPT + { + return 192; + } + + static SBE_CONSTEXPR std::uint16_t settlDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t settlDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t settlDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t settlDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t settlDate() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } + + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeAddendumOutright548 &settlDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 192, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *MaturityDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t maturityDateId() SBE_NOEXCEPT + { + return 541; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maturityDateSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool maturityDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= maturityDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maturityDateEncodingOffset() SBE_NOEXCEPT + { + return 194; + } + + static SBE_CONSTEXPR std::uint16_t maturityDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t maturityDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t maturityDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t maturityDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t maturityDate() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } + + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 194, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeAddendumOutright548 &maturityDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 194, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *CalculatedCcyLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t calculatedCcyLastQtyId() SBE_NOEXCEPT + { + return 1056; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t calculatedCcyLastQtySinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool calculatedCcyLastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= calculatedCcyLastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t calculatedCcyLastQtyEncodingOffset() SBE_NOEXCEPT + { + return 196; + } + +private: + Decimal64NULL m_calculatedCcyLastQty; + +public: + SBE_NODISCARD Decimal64NULL &calculatedCcyLastQty() + { + m_calculatedCcyLastQty.wrap(m_buffer, m_offset + 196, m_actingVersion, m_bufferLength); + return m_calculatedCcyLastQty; + } + + SBE_NODISCARD static const char *GrossTradeAmtMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t grossTradeAmtId() SBE_NOEXCEPT + { + return 381; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t grossTradeAmtSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool grossTradeAmtInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= grossTradeAmtSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t grossTradeAmtEncodingOffset() SBE_NOEXCEPT + { + return 205; + } + +private: + Decimal64NULL m_grossTradeAmt; + +public: + SBE_NODISCARD Decimal64NULL &grossTradeAmt() + { + m_grossTradeAmt.wrap(m_buffer, m_offset + 205, m_actingVersion, m_bufferLength); + return m_grossTradeAmt; + } + + SBE_NODISCARD static const char *BenchmarkPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t benchmarkPriceId() SBE_NOEXCEPT + { + return 6262; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t benchmarkPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool benchmarkPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= benchmarkPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t benchmarkPriceEncodingOffset() SBE_NOEXCEPT + { + return 214; + } + +private: + PRICENULL9 m_benchmarkPrice; + +public: + SBE_NODISCARD PRICENULL9 &benchmarkPrice() + { + m_benchmarkPrice.wrap(m_buffer, m_offset + 214, m_actingVersion, m_bufferLength); + return m_benchmarkPrice; + } + + class NoFills + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(15)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 15; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 15; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoFills &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT + { + return 1364; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_fillPx; + +public: + SBE_NODISCARD PRICE9 &fillPx() + { + m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_fillPx; + } + + SBE_NODISCARD static const char *FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT + { + return 1365; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillQtyEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT + { + return 1363; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillExecIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char fillExecID(const std::uint64_t index) const + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } + + NoFills &fillExecID(const std::uint64_t index, const char value) + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getFillExecID(char *const dst, const std::uint64_t length) const + { + if (length > 2) + { + throw std::runtime_error("length too large for getFillExecID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } + + NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); + return *this; + } + + NoFills &putFillExecID( + const char value0, + const char value1) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getFillExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getFillExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getFillExecIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getFillExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoFills &putFillExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #else + NoFills &putFillExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *FillYieldTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT + { + return 1622; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillYieldTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillYieldTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingOffset() SBE_NOEXCEPT + { + return 14; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return (val); + } + + NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoFills writer) + { + builder << '{'; + builder << R"("FillPx": )"; + builder << writer.fillPx(); + + builder << ", "; + builder << R"("FillQty": )"; + builder << +writer.fillQty(); + + builder << ", "; + builder << R"("FillExecID": )"; + builder << '"' << + writer.getFillExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("FillYieldType": )"; + builder << +writer.fillYieldType(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)27); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 27; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoFills m_noFills; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 27; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT + { + return 1362; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoFills &noFills() + { + m_noFills.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoFills &noFillsCount(const std::uint8_t count) + { + m_noFills.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noFillsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoOrderEvents &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *OrderEventPxMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT { - return 1799; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderEventPxSinceVersion(); + return m_actingVersion >= noFillsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoOrderEvents + { private: - PRICE9 m_orderEventPx; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; + + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - SBE_NODISCARD PRICE9 &orderEventPx() { - m_orderEventPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_orderEventPx; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - SBE_NODISCARD static const char *OrderEventTextMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT { - return 1802; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTextSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTextSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTextEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - orderEventTextEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char orderEventText(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); - return (val); - } - - NoOrderEvents & - orderEventText(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getOrderEventText(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error( - "length too large for getOrderEventText [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 8, - sizeof(char) * static_cast(length)); - return length; - } - - NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getOrderEventTextAsString() const { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getOrderEventTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrderEventTextAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getOrderEventTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoOrderEvents &putOrderEventText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } - - return *this; - } -#else - NoOrderEvents &putOrderEventText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT { - return 1797; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingOffset() SBE_NOEXCEPT { - return 13; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT { - return 1800; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT { - return 1796; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD TradeAddendum::Value orderEventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); - return TradeAddendum::get((val)); - } - - NoOrderEvents & - orderEventType(const TradeAddendum::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT { - return 1798; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingOffset() SBE_NOEXCEPT { - return 22; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); - return (val); - } - - NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *OriginalOrderEventExecIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - originalOrderEventExecIDId() SBE_NOEXCEPT { - return 6555; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - originalOrderEventExecIDSinceVersion() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD bool - originalOrderEventExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= originalOrderEventExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - originalOrderEventExecIDEncodingOffset() SBE_NOEXCEPT { - return 23; - } - - static SBE_CONSTEXPR std::uint32_t - originalOrderEventExecIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t - originalOrderEventExecIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t - originalOrderEventExecIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - originalOrderEventExecIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t - originalOrderEventExecID() const SBE_NOEXCEPT { - if (m_actingVersion < 3) { - return 4294967295; - } - - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents & - originalOrderEventExecID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint32_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderEvents writer) { - builder << '{'; - builder << R"("OrderEventPx": )"; - builder << writer.orderEventPx(); - - builder << ", "; - builder << R"("OrderEventText": )"; - builder << '"' << writer.getOrderEventTextAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("OrderEventExecID": )"; - builder << +writer.orderEventExecID(); - - builder << ", "; - builder << R"("OrderEventQty": )"; - builder << +writer.orderEventQty(); - - builder << ", "; - builder << R"("OrderEventType": )"; - builder << '"' << writer.orderEventType() << '"'; - - builder << ", "; - builder << R"("OrderEventReason": )"; - builder << +writer.orderEventReason(); - - builder << ", "; - builder << R"("OriginalOrderEventExecID": )"; - builder << +writer.originalOrderEventExecID(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(45)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 45; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 45; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoOrderEvents &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *OrderEventPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT + { + return 1799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_orderEventPx; + +public: + SBE_NODISCARD PRICE9 &orderEventPx() + { + m_orderEventPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_orderEventPx; + } + + SBE_NODISCARD static const char *OrderEventTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT + { + return 1802; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTextSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTextSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTextEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t orderEventTextEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } + + SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } + + SBE_NODISCARD char orderEventText(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); + return (val); + } + + NoOrderEvents &orderEventText(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrderEventText(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getOrderEventText [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 8, sizeof(char) * static_cast(length)); + return length; + } + + NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getOrderEventTextAsString() const + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrderEventTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrderEventTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrderEventTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoOrderEvents &putOrderEventText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } + + return *this; + } + #else + NoOrderEvents &putOrderEventText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT + { + return 1797; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingOffset() SBE_NOEXCEPT + { + return 13; + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT + { + return 1800; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventQtyEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT + { + return 1796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD TradeAddendum::Value orderEventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return TradeAddendum::get((val)); + } + + NoOrderEvents &orderEventType(const TradeAddendum::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT + { + return 1798; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventReasonEncodingOffset() SBE_NOEXCEPT + { + return 22; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t orderEventReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); + return (val); + } + + NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OriginalOrderEventExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t originalOrderEventExecIDId() SBE_NOEXCEPT + { + return 6555; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t originalOrderEventExecIDSinceVersion() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD bool originalOrderEventExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= originalOrderEventExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t originalOrderEventExecIDEncodingOffset() SBE_NOEXCEPT + { + return 23; + } + + static SBE_CONSTEXPR std::uint32_t originalOrderEventExecIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t originalOrderEventExecIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t originalOrderEventExecIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t originalOrderEventExecIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t originalOrderEventExecID() const SBE_NOEXCEPT + { + if (m_actingVersion < 3) + { + return UINT32_C(0xffffffff); + } + + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &originalOrderEventExecID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *ContraGrossTradeAmtMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t contraGrossTradeAmtId() SBE_NOEXCEPT + { + return 5542; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t contraGrossTradeAmtSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool contraGrossTradeAmtInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= contraGrossTradeAmtSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t contraGrossTradeAmtEncodingOffset() SBE_NOEXCEPT + { + return 27; + } + +private: + Decimal64NULL m_contraGrossTradeAmt; + +public: + SBE_NODISCARD Decimal64NULL &contraGrossTradeAmt() + { + m_contraGrossTradeAmt.wrap(m_buffer, m_offset + 27, m_actingVersion, m_bufferLength); + return m_contraGrossTradeAmt; + } + + SBE_NODISCARD static const char *ContraCalculatedCcyLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t contraCalculatedCcyLastQtyId() SBE_NOEXCEPT + { + return 5971; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t contraCalculatedCcyLastQtySinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool contraCalculatedCcyLastQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= contraCalculatedCcyLastQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t contraCalculatedCcyLastQtyEncodingOffset() SBE_NOEXCEPT + { + return 36; + } + +private: + Decimal64NULL m_contraCalculatedCcyLastQty; + +public: + SBE_NODISCARD Decimal64NULL &contraCalculatedCcyLastQty() + { + m_contraCalculatedCcyLastQty.wrap(m_buffer, m_offset + 36, m_actingVersion, m_bufferLength); + return m_contraCalculatedCcyLastQty; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoOrderEvents writer) + { + builder << '{'; + builder << R"("OrderEventPx": )"; + builder << writer.orderEventPx(); + + builder << ", "; + builder << R"("OrderEventText": )"; + builder << '"' << + writer.getOrderEventTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("OrderEventExecID": )"; + builder << +writer.orderEventExecID(); + + builder << ", "; + builder << R"("OrderEventQty": )"; + builder << +writer.orderEventQty(); + + builder << ", "; + builder << R"("OrderEventType": )"; + builder << '"' << writer.orderEventType() << '"'; + + builder << ", "; + builder << R"("OrderEventReason": )"; + builder << +writer.orderEventReason(); + + builder << ", "; + builder << R"("OriginalOrderEventExecID": )"; + builder << +writer.originalOrderEventExecID(); + + builder << ", "; + builder << R"("ContraGrossTradeAmt": )"; + if (writer.contraGrossTradeAmtInActingVersion()) + { + builder << writer.contraGrossTradeAmt(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("ContraCalculatedCcyLastQty": )"; + if (writer.contraCalculatedCcyLastQtyInActingVersion()) + { + builder << writer.contraCalculatedCcyLastQty(); + } + else + { + builder << "{}"; + } + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoOrderEvents m_noOrderEvents; +private: + NoOrderEvents m_noOrderEvents; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderEventsId() SBE_NOEXCEPT { - return 1795; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderEventsId() SBE_NOEXCEPT + { + return 1795; + } - SBE_NODISCARD inline NoOrderEvents &noOrderEvents() { - m_noOrderEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } + SBE_NODISCARD inline NoOrderEvents &noOrderEvents() + { + m_noOrderEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - NoOrderEvents &noOrderEventsCount(const std::uint8_t count) { - m_noOrderEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } + NoOrderEvents &noOrderEventsCount(const std::uint8_t count) + { + m_noOrderEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderEventsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noOrderEventsSinceVersion(); + return m_actingVersion >= noOrderEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportTradeAddendumOutright548 _writer) { - ExecutionReportTradeAddendumOutright548 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportTradeAddendumOutright548", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportTradeAddendumOutright548 _writer) +{ + ExecutionReportTradeAddendumOutright548 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << '{'; + builder << R"("Name": "ExecutionReportTradeAddendumOutright548", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("LastPx": )"; - builder << writer.lastPx(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + builder << ", "; + builder << R"("LastPx": )"; + builder << writer.lastPx(); - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("SecExecID": )"; - builder << +writer.secExecID(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("OrigSecondaryExecutionID": )"; - builder << +writer.origSecondaryExecutionID(); + builder << ", "; + builder << R"("SecExecID": )"; + builder << +writer.secExecID(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("OrigSecondaryExecutionID": )"; + builder << +writer.origSecondaryExecutionID(); - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("LastQty": )"; - builder << +writer.lastQty(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("SideTradeID": )"; - builder << +writer.sideTradeID(); + builder << ", "; + builder << R"("LastQty": )"; + builder << +writer.lastQty(); - builder << ", "; - builder << R"("OrigSideTradeID": )"; - builder << +writer.origSideTradeID(); + builder << ", "; + builder << R"("SideTradeID": )"; + builder << +writer.sideTradeID(); - builder << ", "; - builder << R"("TradeDate": )"; - builder << +writer.tradeDate(); + builder << ", "; + builder << R"("OrigSideTradeID": )"; + builder << +writer.origSideTradeID(); - builder << ", "; - builder << R"("OrdStatus": )"; - builder << '"' << writer.ordStatus() << '"'; + builder << ", "; + builder << R"("TradeDate": )"; + builder << +writer.tradeDate(); - builder << ", "; - builder << R"("ExecType": )"; - builder << '"' << writer.execType() << '"'; + builder << ", "; + builder << R"("OrdStatus": )"; + builder << '"' << writer.ordStatus() << '"'; - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + builder << ", "; + builder << R"("ExecType": )"; + builder << '"' << writer.execType() << '"'; - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoFills": [)"; - writer.noFills().forEach([&](NoFills &noFills) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noFills; - }); - builder << ']'; - } + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderEvents": [)"; - writer.noOrderEvents().forEach([&](NoOrderEvents &noOrderEvents) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderEvents; - }); - builder << ']'; - } + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } - builder << '}'; + builder << ", "; + builder << R"("TrdType": )"; + builder << +writer.trdType(); - return builder; - } + builder << ", "; + builder << R"("ExecRestatementReason": )"; + builder << '"' << writer.execRestatementReason() << '"'; - void skip() { - noFills().forEach([](NoFills e) { e.skip(); }); - noOrderEvents().forEach([](NoOrderEvents e) { e.skip(); }); - } + builder << ", "; + builder << R"("SettlDate": )"; + builder << +writer.settlDate(); - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + builder << ", "; + builder << R"("MaturityDate": )"; + builder << +writer.maturityDate(); - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoFillsLength = 0, std::size_t NoOrderEventsLength = 0) { + builder << ", "; + builder << R"("CalculatedCcyLastQty": )"; + if (writer.calculatedCcyLastQtyInActingVersion()) + { + builder << writer.calculatedCcyLastQty(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("GrossTradeAmt": )"; + if (writer.grossTradeAmtInActingVersion()) + { + builder << writer.grossTradeAmt(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("BenchmarkPrice": )"; + if (writer.benchmarkPriceInActingVersion()) + { + builder << writer.benchmarkPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoFills": [)"; + writer.noFills().forEach( + [&](NoFills &noFills) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noFills; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderEvents": [)"; + writer.noOrderEvents().forEach( + [&](NoOrderEvents &noOrderEvents) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderEvents; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noFillsGroup { noFills() }; + while (noFillsGroup.hasNext()) + { + noFillsGroup.next().skip(); + } + auto &noOrderEventsGroup { noOrderEvents() }; + while (noOrderEventsGroup.hasNext()) + { + noOrderEventsGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noFillsLength = 0, + std::size_t noOrderEventsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoFills::sbeHeaderSize(); - if (NoFillsLength > 254) { - throw std::runtime_error( - "NoFillsLength outside of allowed range [E110]"); - } - length += NoFillsLength * NoFills::sbeBlockLength(); + length += NoFills::sbeHeaderSize(); + if (noFillsLength > 254LL) + { + throw std::runtime_error("noFillsLength outside of allowed range [E110]"); + } + length += noFillsLength *NoFills::sbeBlockLength(); - length += NoOrderEvents::sbeHeaderSize(); - if (NoOrderEventsLength > 254) { - throw std::runtime_error( - "NoOrderEventsLength outside of allowed range [E110]"); - } - length += NoOrderEventsLength * NoOrderEvents::sbeBlockLength(); - return length; + length += NoOrderEvents::sbeHeaderSize(); + if (noOrderEventsLength > 254LL) + { + throw std::runtime_error("noOrderEventsLength outside of allowed range [E110]"); + } + length += noOrderEventsLength *NoOrderEvents::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumSpread549.h b/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumSpread549.h index f11e239e7..821583834 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumSpread549.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumSpread549.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,5014 +86,5415 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportTradeAddendumSpread549 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - ExecutionReportTradeAddendumSpread549() = default; - - ExecutionReportTradeAddendumSpread549( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - ExecutionReportTradeAddendumSpread549( - char *buffer, const std::uint64_t bufferLength) - : ExecutionReportTradeAddendumSpread549( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - ExecutionReportTradeAddendumSpread549( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportTradeAddendumSpread549( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)187; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)549; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - ExecutionReportTradeAddendumSpread549 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeAddendumSpread549( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - ExecutionReportTradeAddendumSpread549 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = ExecutionReportTradeAddendumSpread549( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - ExecutionReportTradeAddendumSpread549 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeAddendumSpread549( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportTradeAddendumSpread549 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpread549 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= uUIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpread549 & - uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } - - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } - - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumSpread549 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumSpread549 & - putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } - - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumSpread549 & - putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumSpread549 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumSpread549 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumSpread549 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumSpread549 & - putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumSpread549 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= clOrdIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } - - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumSpread549 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumSpread549 & - putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumSpread549 & - putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumSpread549 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 92; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpread549 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT { return 31; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastPxEncodingOffset() SBE_NOEXCEPT { - return 100; - } - - private: - PRICE9 m_lastPx; - - public: - SBE_NODISCARD PRICE9 &lastPx() { - m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); - return m_lastPx; - } - - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 108; - } - - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpread549 & - orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= transactTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 116; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpread549 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 124; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpread549 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT { return 527; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - secExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= secExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - secExecIDEncodingOffset() SBE_NOEXCEPT { - return 132; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpread549 & - secExecID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *OrigSecondaryExecutionIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - origSecondaryExecutionIDId() SBE_NOEXCEPT { - return 9703; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool origSecondaryExecutionIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= origSecondaryExecutionIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - origSecondaryExecutionIDEncodingOffset() SBE_NOEXCEPT { - return 140; - } - - static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - origSecondaryExecutionIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t origSecondaryExecutionID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpread549 & - origSecondaryExecutionID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 148; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 148; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 148; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 148 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumSpread549 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 148 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 148, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumSpread549 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 148, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 148; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 148; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumSpread549 & - putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 148, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 148 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumSpread549 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 148, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 148 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 153; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 153, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpread549 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 153, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDTradeEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDTradeEntryIDId() SBE_NOEXCEPT { - return 37711; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDTradeEntryIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDTradeEntryIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDTradeEntryIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingOffset() SBE_NOEXCEPT { - return 157; - } - - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t mDTradeEntryID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpread549 & - mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT { return 32; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastQtyEncodingOffset() SBE_NOEXCEPT { - return 161; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpread549 & - lastQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT { - return 1506; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideTradeIDEncodingOffset() SBE_NOEXCEPT { - return 165; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 165, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpread549 & - sideTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 165, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrigSideTradeIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t origSideTradeIDId() SBE_NOEXCEPT { - return 1507; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - origSideTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool origSideTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= origSideTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - origSideTradeIDEncodingOffset() SBE_NOEXCEPT { - return 169; - } - - static SBE_CONSTEXPR std::uint32_t origSideTradeIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t origSideTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t origSideTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - origSideTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t origSideTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpread549 & - origSideTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT { return 75; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradeDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradeDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeDateEncodingOffset() SBE_NOEXCEPT { - return 173; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - ExecutionReportTradeAddendumSpread549 & - tradeDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordStatusSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 175; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrdStatusTrdCxl::Value ordStatus() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 175, sizeof(char)); - return OrdStatusTrdCxl::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - ordStatus(const OrdStatusTrdCxl::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 175, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 176; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ExecTypTrdCxl::Value execType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 176, sizeof(char)); - return ExecTypTrdCxl::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - execType(const ExecTypTrdCxl::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 176, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 177; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 177, sizeof(char)); - return OrderType::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 177, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 178; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 178, sizeof(std::uint8_t)); - return SideReq::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 178, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 179; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 179, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 179, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= possRetransFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 180; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 180, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 180, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *TotalNumSecuritiesMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t totalNumSecuritiesId() SBE_NOEXCEPT { - return 393; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totalNumSecuritiesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool totalNumSecuritiesInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= totalNumSecuritiesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totalNumSecuritiesEncodingOffset() SBE_NOEXCEPT { - return 181; - } - - static SBE_CONSTEXPR std::uint8_t - totalNumSecuritiesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - totalNumSecuritiesEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t totalNumSecurities() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint8_t)); - return (val); - } - - ExecutionReportTradeAddendumSpread549 & - totalNumSecurities(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execInstSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 182; - } - - private: - ExecInst m_execInst; - - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 182, m_actingVersion, m_bufferLength); - return m_execInst; - } - - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= executionModeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 183; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 183, sizeof(char)); - return ExecMode::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 183, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= liquidityFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 184; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 184, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 184, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= managedOrderSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 185; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= shortSaleTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 186; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 186, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } - - ExecutionReportTradeAddendumSpread549 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 186, &val, sizeof(std::uint8_t)); - return *this; - } - - class NoFills { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)15); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 15; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 15; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { +class ExecutionReportTradeAddendumSpread549 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(187); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(549); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + ExecutionReportTradeAddendumSpread549() = default; + + ExecutionReportTradeAddendumSpread549( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + ExecutionReportTradeAddendumSpread549(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportTradeAddendumSpread549(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + ExecutionReportTradeAddendumSpread549( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportTradeAddendumSpread549(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(187); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(549); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + ExecutionReportTradeAddendumSpread549 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeAddendumSpread549(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + ExecutionReportTradeAddendumSpread549 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = ExecutionReportTradeAddendumSpread549( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + ExecutionReportTradeAddendumSpread549 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeAddendumSpread549(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + ExecutionReportTradeAddendumSpread549 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + } + return position; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportTradeAddendumSpread549 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoFills &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - return *this; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD static const char * - FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT { - return 1364; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillPxSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICE9 m_fillPx; + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - public: - SBE_NODISCARD PRICE9 &fillPx() { - m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_fillPx; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - SBE_NODISCARD static const char * - FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT { - return 1365; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT { + ExecutionReportTradeAddendumSpread549 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillQtySinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportTradeAddendumSpread549 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT { - return 1363; - } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillExecIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillExecIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char fillExecID(const std::uint64_t index) const { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy( - &val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - NoFills &fillExecID(const std::uint64_t index, const char value) { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E105]"); - } + ExecutionReportTradeAddendumSpread549 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy( - m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getFillExecID(char *const dst, const std::uint64_t length) const { - if (length > 2) { - throw std::runtime_error( - "length too large for getFillExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); - return *this; - } + ExecutionReportTradeAddendumSpread549 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - NoFills & - putFillExecID(const char value0, const char value1) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - return *this; - } + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - SBE_NODISCARD std::string getFillExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + return result; + } - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - return result; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - std::string getFillExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getFillExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getFillExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NoFills &putFillExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumSpread549 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#else - NoFills &putFillExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + return *this; + } + #else + ExecutionReportTradeAddendumSpread549 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *FillYieldTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT { - return 1622; - } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillYieldTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillYieldTypeSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return (val); - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoFills writer) { - builder << '{'; - builder << R"("FillPx": )"; - builder << writer.fillPx(); + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - builder << ", "; - builder << R"("FillQty": )"; - builder << +writer.fillQty(); + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - builder << ", "; - builder << R"("FillExecID": )"; - builder << '"' << writer.getFillExecIDAsJsonEscapedString().c_str() - << '"'; + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - builder << ", "; - builder << R"("FillYieldType": )"; - builder << +writer.fillYieldType(); + ExecutionReportTradeAddendumSpread549 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - builder << '}'; + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - return builder; - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - void skip() {} + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + ExecutionReportTradeAddendumSpread549 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - private: - NoFills m_noFills; + return result; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT { - return 1362; - } + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - SBE_NODISCARD inline NoFills &noFills() { - m_noFills.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - NoFills &noFillsCount(const std::uint8_t count) { - m_noFills.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noFillsSinceVersion() SBE_NOEXCEPT { - return 0; - } + return oss.str(); + } - SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT { + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumSpread549 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeAddendumSpread549 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noFillsSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoLegs { + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } + + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeAddendumSpread549 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeAddendumSpread549 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumSpread549 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeAddendumSpread549 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpread549 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT + { + return 31; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastPxSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastPxEncodingOffset() SBE_NOEXCEPT + { + return 100; + } + +private: + PRICE9 m_lastPx; + +public: + SBE_NODISCARD PRICE9 &lastPx() + { + m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); + return m_lastPx; + } + + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 108; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpread549 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= transactTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 116; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpread549 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 124; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpread549 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT + { + return 527; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t secExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= secExecIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t secExecIDEncodingOffset() SBE_NOEXCEPT + { + return 132; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpread549 &secExecID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrigSecondaryExecutionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origSecondaryExecutionIDId() SBE_NOEXCEPT + { + return 9703; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool origSecondaryExecutionIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origSecondaryExecutionIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origSecondaryExecutionIDEncodingOffset() SBE_NOEXCEPT + { + return 140; + } + + static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t origSecondaryExecutionIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t origSecondaryExecutionID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpread549 &origSecondaryExecutionID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 148; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 148; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 148; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 148 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeAddendumSpread549 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 148 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 148, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeAddendumSpread549 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 148, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 148; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 148; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumSpread549 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 148, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 148 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeAddendumSpread549 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 148, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 148 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 153; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 153, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumSpread549 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 153, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *MDTradeEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDTradeEntryIDId() SBE_NOEXCEPT + { + return 37711; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDTradeEntryIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDTradeEntryIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= mDTradeEntryIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDTradeEntryIDEncodingOffset() SBE_NOEXCEPT + { + return 157; + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t mDTradeEntryIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t mDTradeEntryID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumSpread549 &mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT + { + return 32; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastQtyEncodingOffset() SBE_NOEXCEPT + { + return 161; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumSpread549 &lastQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT + { + return 1506; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideTradeIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 165; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 165, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumSpread549 &sideTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 165, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrigSideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origSideTradeIDId() SBE_NOEXCEPT + { + return 1507; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origSideTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool origSideTradeIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origSideTradeIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origSideTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 169; + } + + static SBE_CONSTEXPR std::uint32_t origSideTradeIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t origSideTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t origSideTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t origSideTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t origSideTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumSpread549 &origSideTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT + { + return 75; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradeDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= tradeDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeDateEncodingOffset() SBE_NOEXCEPT + { + return 173; + } + + static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeAddendumSpread549 &tradeDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordStatusSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 175; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char ordStatusRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(char)); + return (val); + } + + SBE_NODISCARD OrdStatusTrdCxl::Value ordStatus() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(char)); + return OrdStatusTrdCxl::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &ordStatus(const OrdStatusTrdCxl::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 175, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 176; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char execTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 176, sizeof(char)); + return (val); + } + + SBE_NODISCARD ExecTypTrdCxl::Value execType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 176, sizeof(char)); + return ExecTypTrdCxl::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &execType(const ExecTypTrdCxl::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 176, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 177; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(char)); + return (val); + } + + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(char)); + return OrderType::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 177, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 178; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 178, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 178, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 178, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= manualOrderIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 179; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 179, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 179, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 179, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= possRetransFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 180; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 180, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 180, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 180, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *TotalNumSecuritiesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t totalNumSecuritiesId() SBE_NOEXCEPT + { + return 393; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totalNumSecuritiesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool totalNumSecuritiesInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= totalNumSecuritiesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totalNumSecuritiesEncodingOffset() SBE_NOEXCEPT + { + return 181; + } + + static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t totalNumSecuritiesEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t totalNumSecurities() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint8_t)); + return (val); + } + + ExecutionReportTradeAddendumSpread549 &totalNumSecurities(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execInstSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 182; + } + +private: + ExecInst m_execInst; + +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 182, m_actingVersion, m_bufferLength); + return m_execInst; + } + + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= executionModeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 183; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 183, sizeof(char)); + return (val); + } + + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 183, sizeof(char)); + return ExecMode::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 183, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= liquidityFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 184; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 184, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 184, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 184, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= managedOrderSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 185; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= shortSaleTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 186; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 186, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 186, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } + + ExecutionReportTradeAddendumSpread549 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 186, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoFills + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(15)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 15; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 15; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoFills &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT + { + return 1364; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_fillPx; + +public: + SBE_NODISCARD PRICE9 &fillPx() + { + m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_fillPx; + } + + SBE_NODISCARD static const char *FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT + { + return 1365; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillQtyEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT + { + return 1363; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillExecIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char fillExecID(const std::uint64_t index) const + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } + + NoFills &fillExecID(const std::uint64_t index, const char value) + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getFillExecID(char *const dst, const std::uint64_t length) const + { + if (length > 2) + { + throw std::runtime_error("length too large for getFillExecID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } + + NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); + return *this; + } + + NoFills &putFillExecID( + const char value0, + const char value1) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getFillExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getFillExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getFillExecIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getFillExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoFills &putFillExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #else + NoFills &putFillExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *FillYieldTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT + { + return 1622; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillYieldTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillYieldTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingOffset() SBE_NOEXCEPT + { + return 14; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return (val); + } + + NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoFills writer) + { + builder << '{'; + builder << R"("FillPx": )"; + builder << writer.fillPx(); + + builder << ", "; + builder << R"("FillQty": )"; + builder << +writer.fillQty(); + + builder << ", "; + builder << R"("FillExecID": )"; + builder << '"' << + writer.getFillExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("FillYieldType": )"; + builder << +writer.fillYieldType(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)41); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 41; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoFills m_noFills; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 41; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT + { + return 1362; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoFills &noFills() + { + m_noFills.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoFills &noFillsCount(const std::uint8_t count) + { + m_noFills.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noFillsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoLegs &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - LegExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legExecIDId() SBE_NOEXCEPT { - return 1893; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legExecIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legExecIDSinceVersion(); + return m_actingVersion >= noFillsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legExecIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t legExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t legExecIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t legExecIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t legExecIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t legExecID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoLegs &legExecID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LegLastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legLastPxId() SBE_NOEXCEPT { - return 637; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legLastPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legLastPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legLastPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legLastPxEncodingOffset() SBE_NOEXCEPT { - return 8; - } + } + class NoLegs + { private: - PRICE9 m_legLastPx; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; + + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - SBE_NODISCARD PRICE9 &legLastPx() { - m_legLastPx.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_legLastPx; - } - - SBE_NODISCARD static const char *LegExecRefIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legExecRefIDId() SBE_NOEXCEPT { - return 1901; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legExecRefIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legExecRefIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legExecRefIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legExecRefIDEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::uint64_t legExecRefIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t legExecRefIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t legExecRefIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - legExecRefIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t legExecRefID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoLegs &legExecRefID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LegTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legTradeIDId() SBE_NOEXCEPT { - return 1894; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legTradeIDEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - static SBE_CONSTEXPR std::uint32_t legTradeIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t legTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t legTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t legTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t legTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoLegs &legTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *LegTradeRefIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legTradeRefIDId() SBE_NOEXCEPT { - return 39023; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legTradeRefIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legTradeRefIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legTradeRefIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legTradeRefIDEncodingOffset() SBE_NOEXCEPT { - return 28; - } - - static SBE_CONSTEXPR std::uint32_t legTradeRefIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t legTradeRefIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t legTradeRefIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - legTradeRefIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t legTradeRefID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoLegs &legTradeRefID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *LegSecurityIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legSecurityIDId() SBE_NOEXCEPT { - return 602; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSecurityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legSecurityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legSecurityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSecurityIDEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - static SBE_CONSTEXPR std::int32_t legSecurityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t legSecurityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t legSecurityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - legSecurityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t legSecurityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoLegs &legSecurityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LegLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legLastQtyId() SBE_NOEXCEPT { - return 1418; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legLastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legLastQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legLastQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legLastQtyEncodingOffset() SBE_NOEXCEPT { - return 36; - } - - static SBE_CONSTEXPR std::uint32_t legLastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t legLastQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t legLastQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t legLastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t legLastQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoLegs &legLastQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 36, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LegSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT { - return 624; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legSideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legSideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingOffset() SBE_NOEXCEPT { - return 40; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideReq::Value legSide() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 40, sizeof(std::uint8_t)); - return SideReq::get((val)); - } - - NoLegs &legSide(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 40, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoLegs writer) { - builder << '{'; - builder << R"("LegExecID": )"; - builder << +writer.legExecID(); - - builder << ", "; - builder << R"("LegLastPx": )"; - builder << writer.legLastPx(); - - builder << ", "; - builder << R"("LegExecRefID": )"; - builder << +writer.legExecRefID(); - - builder << ", "; - builder << R"("LegTradeID": )"; - builder << +writer.legTradeID(); - - builder << ", "; - builder << R"("LegTradeRefID": )"; - builder << +writer.legTradeRefID(); - - builder << ", "; - builder << R"("LegSecurityID": )"; - builder << +writer.legSecurityID(); - - builder << ", "; - builder << R"("LegLastQty": )"; - builder << +writer.legLastQty(); - - builder << ", "; - builder << R"("LegSide": )"; - builder << '"' << writer.legSide() << '"'; - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(41)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 41; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 41; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoLegs &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *LegExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legExecIDId() SBE_NOEXCEPT + { + return 1893; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legExecIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t legExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t legExecIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t legExecIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t legExecIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t legExecID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoLegs &legExecID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LegLastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legLastPxId() SBE_NOEXCEPT + { + return 637; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legLastPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legLastPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legLastPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legLastPxEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + +private: + PRICE9 m_legLastPx; + +public: + SBE_NODISCARD PRICE9 &legLastPx() + { + m_legLastPx.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_legLastPx; + } + + SBE_NODISCARD static const char *LegExecRefIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legExecRefIDId() SBE_NOEXCEPT + { + return 1901; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legExecRefIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legExecRefIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legExecRefIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legExecRefIDEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::uint64_t legExecRefIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t legExecRefIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t legExecRefIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t legExecRefIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t legExecRefID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoLegs &legExecRefID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LegTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legTradeIDId() SBE_NOEXCEPT + { + return 1894; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legTradeIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legTradeIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + static SBE_CONSTEXPR std::uint32_t legTradeIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t legTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t legTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t legTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t legTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoLegs &legTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LegTradeRefIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legTradeRefIDId() SBE_NOEXCEPT + { + return 39023; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legTradeRefIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legTradeRefIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legTradeRefIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legTradeRefIDEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + static SBE_CONSTEXPR std::uint32_t legTradeRefIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t legTradeRefIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t legTradeRefIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t legTradeRefIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t legTradeRefID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoLegs &legTradeRefID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LegSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legSecurityIDId() SBE_NOEXCEPT + { + return 602; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSecurityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legSecurityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSecurityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSecurityIDEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + + static SBE_CONSTEXPR std::int32_t legSecurityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t legSecurityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t legSecurityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t legSecurityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t legSecurityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoLegs &legSecurityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *LegLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legLastQtyId() SBE_NOEXCEPT + { + return 1418; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legLastQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legLastQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legLastQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legLastQtyEncodingOffset() SBE_NOEXCEPT + { + return 36; + } + + static SBE_CONSTEXPR std::uint32_t legLastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t legLastQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t legLastQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t legLastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t legLastQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoLegs &legLastQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 36, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LegSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT + { + return 624; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legSideInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSideSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingOffset() SBE_NOEXCEPT + { + return 40; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t legSideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 40, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value legSide() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 40, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + NoLegs &legSide(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 40, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoLegs writer) + { + builder << '{'; + builder << R"("LegExecID": )"; + builder << +writer.legExecID(); + + builder << ", "; + builder << R"("LegLastPx": )"; + builder << writer.legLastPx(); + + builder << ", "; + builder << R"("LegExecRefID": )"; + builder << +writer.legExecRefID(); + + builder << ", "; + builder << R"("LegTradeID": )"; + builder << +writer.legTradeID(); + + builder << ", "; + builder << R"("LegTradeRefID": )"; + builder << +writer.legTradeRefID(); + + builder << ", "; + builder << R"("LegSecurityID": )"; + builder << +writer.legSecurityID(); + + builder << ", "; + builder << R"("LegLastQty": )"; + builder << +writer.legLastQty(); + + builder << ", "; + builder << R"("LegSide": )"; + builder << '"' << writer.legSide() << '"'; + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoLegs m_noLegs; +private: + NoLegs m_noLegs; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT { - return 555; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT + { + return 555; + } - SBE_NODISCARD inline NoLegs &noLegs() { - m_noLegs.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + SBE_NODISCARD inline NoLegs &noLegs() + { + m_noLegs.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLegs; + } - NoLegs &noLegsCount(const std::uint8_t count) { - m_noLegs.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + NoLegs &noLegsCount(const std::uint8_t count) + { + m_noLegs.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLegs; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLegsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLegsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noLegsSinceVersion(); + return m_actingVersion >= noLegsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoOrderEvents { + class NoOrderEvents + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(27)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 27; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 27; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoOrderEvents &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *OrderEventPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT + { + return 1799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_orderEventPx; + +public: + SBE_NODISCARD PRICE9 &orderEventPx() + { + m_orderEventPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_orderEventPx; + } + + SBE_NODISCARD static const char *OrderEventTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT + { + return 1802; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTextSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTextSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTextEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t orderEventTextEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } + + SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } + + SBE_NODISCARD char orderEventText(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); + return (val); + } + + NoOrderEvents &orderEventText(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrderEventText(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getOrderEventText [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 8, sizeof(char) * static_cast(length)); + return length; + } + + NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getOrderEventTextAsString() const + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrderEventTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrderEventTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrderEventTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoOrderEvents &putOrderEventText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } + + return *this; + } + #else + NoOrderEvents &putOrderEventText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT + { + return 1797; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingOffset() SBE_NOEXCEPT + { + return 13; + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT + { + return 1800; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventQtyEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT + { + return 1796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD TradeAddendum::Value orderEventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return TradeAddendum::get((val)); + } + + NoOrderEvents &orderEventType(const TradeAddendum::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT + { + return 1798; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventReasonEncodingOffset() SBE_NOEXCEPT + { + return 22; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t orderEventReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); + return (val); + } + + NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OriginalOrderEventExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t originalOrderEventExecIDId() SBE_NOEXCEPT + { + return 6555; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t originalOrderEventExecIDSinceVersion() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD bool originalOrderEventExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= originalOrderEventExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t originalOrderEventExecIDEncodingOffset() SBE_NOEXCEPT + { + return 23; + } + + static SBE_CONSTEXPR std::uint32_t originalOrderEventExecIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t originalOrderEventExecIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t originalOrderEventExecIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t originalOrderEventExecIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t originalOrderEventExecID() const SBE_NOEXCEPT + { + if (m_actingVersion < 3) + { + return UINT32_C(0xffffffff); + } + + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &originalOrderEventExecID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint32_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoOrderEvents writer) + { + builder << '{'; + builder << R"("OrderEventPx": )"; + builder << writer.orderEventPx(); + + builder << ", "; + builder << R"("OrderEventText": )"; + builder << '"' << + writer.getOrderEventTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("OrderEventExecID": )"; + builder << +writer.orderEventExecID(); + + builder << ", "; + builder << R"("OrderEventQty": )"; + builder << +writer.orderEventQty(); + + builder << ", "; + builder << R"("OrderEventType": )"; + builder << '"' << writer.orderEventType() << '"'; + + builder << ", "; + builder << R"("OrderEventReason": )"; + builder << +writer.orderEventReason(); + + builder << ", "; + builder << R"("OriginalOrderEventExecID": )"; + builder << +writer.originalOrderEventExecID(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)27); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 27; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoOrderEvents m_noOrderEvents; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 27; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderEventsId() SBE_NOEXCEPT + { + return 1795; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoOrderEvents &noOrderEvents() + { + m_noOrderEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoOrderEvents &noOrderEventsCount(const std::uint8_t count) + { + m_noOrderEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderEventsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoOrderEvents &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *OrderEventPxMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT { - return 1799; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderEventPxSinceVersion(); + return m_actingVersion >= noOrderEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICE9 m_orderEventPx; - - public: - SBE_NODISCARD PRICE9 &orderEventPx() { - m_orderEventPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_orderEventPx; - } - - SBE_NODISCARD static const char *OrderEventTextMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT { - return 1802; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTextSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTextSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTextEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - orderEventTextEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char orderEventText(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); - return (val); - } - - NoOrderEvents & - orderEventText(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getOrderEventText(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error( - "length too large for getOrderEventText [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 8, - sizeof(char) * static_cast(length)); - return length; - } - - NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getOrderEventTextAsString() const { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getOrderEventTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrderEventTextAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getOrderEventTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoOrderEvents &putOrderEventText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } - - return *this; - } -#else - NoOrderEvents &putOrderEventText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT { - return 1797; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingOffset() SBE_NOEXCEPT { - return 13; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT { - return 1800; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT { - return 1796; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD TradeAddendum::Value orderEventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); - return TradeAddendum::get((val)); - } - - NoOrderEvents & - orderEventType(const TradeAddendum::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT { - return 1798; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingOffset() SBE_NOEXCEPT { - return 22; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); - return (val); - } - - NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *OriginalOrderEventExecIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - originalOrderEventExecIDId() SBE_NOEXCEPT { - return 6555; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - originalOrderEventExecIDSinceVersion() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD bool - originalOrderEventExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= originalOrderEventExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - originalOrderEventExecIDEncodingOffset() SBE_NOEXCEPT { - return 23; - } - - static SBE_CONSTEXPR std::uint32_t - originalOrderEventExecIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t - originalOrderEventExecIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t - originalOrderEventExecIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - originalOrderEventExecIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t - originalOrderEventExecID() const SBE_NOEXCEPT { - if (m_actingVersion < 3) { - return 4294967295; - } - - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents & - originalOrderEventExecID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint32_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderEvents writer) { - builder << '{'; - builder << R"("OrderEventPx": )"; - builder << writer.orderEventPx(); - - builder << ", "; - builder << R"("OrderEventText": )"; - builder << '"' << writer.getOrderEventTextAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("OrderEventExecID": )"; - builder << +writer.orderEventExecID(); - - builder << ", "; - builder << R"("OrderEventQty": )"; - builder << +writer.orderEventQty(); - - builder << ", "; - builder << R"("OrderEventType": )"; - builder << '"' << writer.orderEventType() << '"'; - - builder << ", "; - builder << R"("OrderEventReason": )"; - builder << +writer.orderEventReason(); - - builder << ", "; - builder << R"("OriginalOrderEventExecID": )"; - builder << +writer.originalOrderEventExecID(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportTradeAddendumSpread549 _writer) +{ + ExecutionReportTradeAddendumSpread549 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "ExecutionReportTradeAddendumSpread549", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("LastPx": )"; + builder << writer.lastPx(); + + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("SecExecID": )"; + builder << +writer.secExecID(); + + builder << ", "; + builder << R"("OrigSecondaryExecutionID": )"; + builder << +writer.origSecondaryExecutionID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("MDTradeEntryID": )"; + builder << +writer.mDTradeEntryID(); + + builder << ", "; + builder << R"("LastQty": )"; + builder << +writer.lastQty(); + + builder << ", "; + builder << R"("SideTradeID": )"; + builder << +writer.sideTradeID(); + + builder << ", "; + builder << R"("OrigSideTradeID": )"; + builder << +writer.origSideTradeID(); + + builder << ", "; + builder << R"("TradeDate": )"; + builder << +writer.tradeDate(); + + builder << ", "; + builder << R"("OrdStatus": )"; + builder << '"' << writer.ordStatus() << '"'; + + builder << ", "; + builder << R"("ExecType": )"; + builder << '"' << writer.execType() << '"'; + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("TotalNumSecurities": )"; + builder << +writer.totalNumSecurities(); + + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoFills": [)"; + writer.noFills().forEach( + [&](NoFills &noFills) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noFills; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLegs": [)"; + writer.noLegs().forEach( + [&](NoLegs &noLegs) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noLegs; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderEvents": [)"; + writer.noOrderEvents().forEach( + [&](NoOrderEvents &noOrderEvents) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderEvents; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noFillsGroup { noFills() }; + while (noFillsGroup.hasNext()) + { + noFillsGroup.next().skip(); + } + auto &noLegsGroup { noLegs() }; + while (noLegsGroup.hasNext()) + { + noLegsGroup.next().skip(); + } + auto &noOrderEventsGroup { noOrderEvents() }; + while (noOrderEventsGroup.hasNext()) + { + noOrderEventsGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noFillsLength = 0, + std::size_t noLegsLength = 0, + std::size_t noOrderEventsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + length += NoFills::sbeHeaderSize(); + if (noFillsLength > 254LL) + { + throw std::runtime_error("noFillsLength outside of allowed range [E110]"); + } + length += noFillsLength *NoFills::sbeBlockLength(); + + length += NoLegs::sbeHeaderSize(); + if (noLegsLength > 254LL) + { + throw std::runtime_error("noLegsLength outside of allowed range [E110]"); + } + length += noLegsLength *NoLegs::sbeBlockLength(); + + length += NoOrderEvents::sbeHeaderSize(); + if (noOrderEventsLength > 254LL) + { + throw std::runtime_error("noOrderEventsLength outside of allowed range [E110]"); + } + length += noOrderEventsLength *NoOrderEvents::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; - - private: - NoOrderEvents m_noOrderEvents; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderEventsId() SBE_NOEXCEPT { - return 1795; - } - - SBE_NODISCARD inline NoOrderEvents &noOrderEvents() { - m_noOrderEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } - - NoOrderEvents &noOrderEventsCount(const std::uint8_t count) { - m_noOrderEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noOrderEventsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportTradeAddendumSpread549 _writer) { - ExecutionReportTradeAddendumSpread549 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportTradeAddendumSpread549", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); - - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("LastPx": )"; - builder << writer.lastPx(); - - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("SecExecID": )"; - builder << +writer.secExecID(); - - builder << ", "; - builder << R"("OrigSecondaryExecutionID": )"; - builder << +writer.origSecondaryExecutionID(); - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("MDTradeEntryID": )"; - builder << +writer.mDTradeEntryID(); - - builder << ", "; - builder << R"("LastQty": )"; - builder << +writer.lastQty(); - - builder << ", "; - builder << R"("SideTradeID": )"; - builder << +writer.sideTradeID(); - - builder << ", "; - builder << R"("OrigSideTradeID": )"; - builder << +writer.origSideTradeID(); - - builder << ", "; - builder << R"("TradeDate": )"; - builder << +writer.tradeDate(); - - builder << ", "; - builder << R"("OrdStatus": )"; - builder << '"' << writer.ordStatus() << '"'; - - builder << ", "; - builder << R"("ExecType": )"; - builder << '"' << writer.execType() << '"'; - - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; - - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; - - builder << ", "; - builder << R"("TotalNumSecurities": )"; - builder << +writer.totalNumSecurities(); - - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); - - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; - - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; - - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; - - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoFills": [)"; - writer.noFills().forEach([&](NoFills &noFills) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noFills; - }); - builder << ']'; - } - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLegs": [)"; - writer.noLegs().forEach([&](NoLegs &noLegs) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noLegs; - }); - builder << ']'; - } - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderEvents": [)"; - writer.noOrderEvents().forEach([&](NoOrderEvents &noOrderEvents) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderEvents; - }); - builder << ']'; - } - - builder << '}'; - - return builder; - } - - void skip() { - noFills().forEach([](NoFills e) { e.skip(); }); - noLegs().forEach([](NoLegs e) { e.skip(); }); - noOrderEvents().forEach([](NoOrderEvents e) { e.skip(); }); - } - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoFillsLength = 0, - std::size_t NoLegsLength = 0, - std::size_t NoOrderEventsLength = 0) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - length += NoFills::sbeHeaderSize(); - if (NoFillsLength > 254) { - throw std::runtime_error( - "NoFillsLength outside of allowed range [E110]"); - } - length += NoFillsLength * NoFills::sbeBlockLength(); - - length += NoLegs::sbeHeaderSize(); - if (NoLegsLength > 254) { - throw std::runtime_error( - "NoLegsLength outside of allowed range [E110]"); - } - length += NoLegsLength * NoLegs::sbeBlockLength(); - - length += NoOrderEvents::sbeHeaderSize(); - if (NoOrderEventsLength > 254) { - throw std::runtime_error( - "NoOrderEventsLength outside of allowed range [E110]"); - } - length += NoOrderEventsLength * NoOrderEvents::sbeBlockLength(); - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumSpreadLeg550.h b/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumSpreadLeg550.h index bf155e26e..d5917c7f7 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumSpreadLeg550.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportTradeAddendumSpreadLeg550.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3780 +86,4267 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportTradeAddendumSpreadLeg550 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - ExecutionReportTradeAddendumSpreadLeg550() = default; - - ExecutionReportTradeAddendumSpreadLeg550( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - ExecutionReportTradeAddendumSpreadLeg550( - char *buffer, const std::uint64_t bufferLength) - : ExecutionReportTradeAddendumSpreadLeg550( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - ExecutionReportTradeAddendumSpreadLeg550( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportTradeAddendumSpreadLeg550( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)176; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)550; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - ExecutionReportTradeAddendumSpreadLeg550 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeAddendumSpreadLeg550( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - ExecutionReportTradeAddendumSpreadLeg550 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = ExecutionReportTradeAddendumSpreadLeg550( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - ExecutionReportTradeAddendumSpreadLeg550 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeAddendumSpreadLeg550( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportTradeAddendumSpreadLeg550 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= uUIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } - - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } - - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumSpreadLeg550 & - putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } - - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumSpreadLeg550 & - putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumSpreadLeg550 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumSpreadLeg550 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumSpreadLeg550 & - putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumSpreadLeg550 & - putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= clOrdIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } - - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumSpreadLeg550 & - putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumSpreadLeg550 & - putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumSpreadLeg550 & - putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 92; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT { return 31; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastPxEncodingOffset() SBE_NOEXCEPT { - return 100; - } - - private: - PRICE9 m_lastPx; - - public: - SBE_NODISCARD PRICE9 &lastPx() { - m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); - return m_lastPx; - } - - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 108; - } - - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= transactTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 116; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 124; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT { return 527; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - secExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= secExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - secExecIDEncodingOffset() SBE_NOEXCEPT { - return 132; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - secExecID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *OrigSecondaryExecutionIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - origSecondaryExecutionIDId() SBE_NOEXCEPT { - return 9703; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool origSecondaryExecutionIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= origSecondaryExecutionIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - origSecondaryExecutionIDEncodingOffset() SBE_NOEXCEPT { - return 140; - } - - static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - origSecondaryExecutionIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - origSecondaryExecutionIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t origSecondaryExecutionID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - origSecondaryExecutionID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 148; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 148; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 148; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 148 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 148 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 148, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeAddendumSpreadLeg550 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 148, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 148; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 148; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeAddendumSpreadLeg550 & - putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 148, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 148 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeAddendumSpreadLeg550 & - putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 148, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 148 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 153; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 153, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 153, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT { return 32; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastQtyEncodingOffset() SBE_NOEXCEPT { - return 157; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - lastQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT { - return 1506; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideTradeIDEncodingOffset() SBE_NOEXCEPT { - return 161; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - sideTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrigSideTradeIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t origSideTradeIDId() SBE_NOEXCEPT { - return 1507; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - origSideTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool origSideTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= origSideTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - origSideTradeIDEncodingOffset() SBE_NOEXCEPT { - return 165; - } - - static SBE_CONSTEXPR std::uint32_t origSideTradeIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t origSideTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t origSideTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - origSideTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t origSideTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 165, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - origSideTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 165, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT { return 75; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradeDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradeDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeDateEncodingOffset() SBE_NOEXCEPT { - return 169; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - tradeDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordStatusSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 171; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrdStatusTrdCxl::Value ordStatus() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); - return OrdStatusTrdCxl::get((val)); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - ordStatus(const OrdStatusTrdCxl::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 171, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 172; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ExecTypTrdCxl::Value execType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 172, sizeof(char)); - return ExecTypTrdCxl::get((val)); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - execType(const ExecTypTrdCxl::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 172, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 173; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= possRetransFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 174; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 174, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 175; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - if (m_actingVersion < 5) { - return SideReq::NULL_VALUE; - } - - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); - return SideReq::get((val)); - } - - ExecutionReportTradeAddendumSpreadLeg550 & - side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 175, &val, sizeof(std::uint8_t)); - return *this; - } - - class NoFills { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)15); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 15; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 15; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { +class ExecutionReportTradeAddendumSpreadLeg550 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(196); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(550); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + ExecutionReportTradeAddendumSpreadLeg550() = default; + + ExecutionReportTradeAddendumSpreadLeg550( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + ExecutionReportTradeAddendumSpreadLeg550(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportTradeAddendumSpreadLeg550(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + ExecutionReportTradeAddendumSpreadLeg550( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportTradeAddendumSpreadLeg550(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(196); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(550); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + ExecutionReportTradeAddendumSpreadLeg550 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeAddendumSpreadLeg550(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + ExecutionReportTradeAddendumSpreadLeg550 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = ExecutionReportTradeAddendumSpreadLeg550( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + ExecutionReportTradeAddendumSpreadLeg550 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeAddendumSpreadLeg550(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + ExecutionReportTradeAddendumSpreadLeg550 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + } + return position; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportTradeAddendumSpreadLeg550 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoFills &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - return *this; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD static const char * - FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT { - return 1364; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillPxSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICE9 m_fillPx; + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - public: - SBE_NODISCARD PRICE9 &fillPx() { - m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_fillPx; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - SBE_NODISCARD static const char * - FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT { - return 1365; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT { + ExecutionReportTradeAddendumSpreadLeg550 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillQtySinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportTradeAddendumSpreadLeg550 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT { - return 1363; - } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillExecIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillExecIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char fillExecID(const std::uint64_t index) const { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy( - &val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - NoFills &fillExecID(const std::uint64_t index, const char value) { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E105]"); - } + ExecutionReportTradeAddendumSpreadLeg550 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy( - m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getFillExecID(char *const dst, const std::uint64_t length) const { - if (length > 2) { - throw std::runtime_error( - "length too large for getFillExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); - return *this; - } + ExecutionReportTradeAddendumSpreadLeg550 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - NoFills & - putFillExecID(const char value0, const char value1) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - return *this; - } + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - SBE_NODISCARD std::string getFillExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + return result; + } - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - return result; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - std::string getFillExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getFillExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getFillExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NoFills &putFillExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumSpreadLeg550 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#else - NoFills &putFillExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + return *this; + } + #else + ExecutionReportTradeAddendumSpreadLeg550 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *FillYieldTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT { - return 1622; - } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillYieldTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillYieldTypeSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return (val); - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoFills writer) { - builder << '{'; - builder << R"("FillPx": )"; - builder << writer.fillPx(); + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - builder << ", "; - builder << R"("FillQty": )"; - builder << +writer.fillQty(); + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - builder << ", "; - builder << R"("FillExecID": )"; - builder << '"' << writer.getFillExecIDAsJsonEscapedString().c_str() - << '"'; + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - builder << ", "; - builder << R"("FillYieldType": )"; - builder << +writer.fillYieldType(); + ExecutionReportTradeAddendumSpreadLeg550 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - builder << '}'; + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - return builder; - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - void skip() {} + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + ExecutionReportTradeAddendumSpreadLeg550 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - private: - NoFills m_noFills; + return result; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT { - return 1362; - } + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - SBE_NODISCARD inline NoFills &noFills() { - m_noFills.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - NoFills &noFillsCount(const std::uint8_t count) { - m_noFills.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noFillsSinceVersion() SBE_NOEXCEPT { - return 0; - } + return oss.str(); + } - SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT { + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumSpreadLeg550 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeAddendumSpreadLeg550 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noFillsSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoOrderEvents { + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } + + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeAddendumSpreadLeg550 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumSpreadLeg550 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeAddendumSpreadLeg550 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT + { + return 31; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastPxSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastPxEncodingOffset() SBE_NOEXCEPT + { + return 100; + } + +private: + PRICE9 m_lastPx; + +public: + SBE_NODISCARD PRICE9 &lastPx() + { + m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); + return m_lastPx; + } + + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 108; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= transactTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 116; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 124; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT + { + return 527; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t secExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= secExecIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t secExecIDEncodingOffset() SBE_NOEXCEPT + { + return 132; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &secExecID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrigSecondaryExecutionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origSecondaryExecutionIDId() SBE_NOEXCEPT + { + return 9703; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool origSecondaryExecutionIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origSecondaryExecutionIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origSecondaryExecutionIDEncodingOffset() SBE_NOEXCEPT + { + return 140; + } + + static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t origSecondaryExecutionIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t origSecondaryExecutionIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t origSecondaryExecutionID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &origSecondaryExecutionID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 148; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 148; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 148; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 148 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 148 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 148, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeAddendumSpreadLeg550 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 148, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 148; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 148; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeAddendumSpreadLeg550 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 148, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 148 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeAddendumSpreadLeg550 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 148, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 148 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 153; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 153, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 153, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT + { + return 32; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastQtyEncodingOffset() SBE_NOEXCEPT + { + return 157; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &lastQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT + { + return 1506; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideTradeIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 161; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &sideTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrigSideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origSideTradeIDId() SBE_NOEXCEPT + { + return 1507; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origSideTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool origSideTradeIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origSideTradeIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origSideTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 165; + } + + static SBE_CONSTEXPR std::uint32_t origSideTradeIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t origSideTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t origSideTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t origSideTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t origSideTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 165, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &origSideTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 165, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT + { + return 75; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradeDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= tradeDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeDateEncodingOffset() SBE_NOEXCEPT + { + return 169; + } + + static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 169, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &tradeDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 169, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordStatusSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 171; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char ordStatusRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); + return (val); + } + + SBE_NODISCARD OrdStatusTrdCxl::Value ordStatus() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 171, sizeof(char)); + return OrdStatusTrdCxl::get((val)); + } + + ExecutionReportTradeAddendumSpreadLeg550 &ordStatus(const OrdStatusTrdCxl::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 171, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 172; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char execTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(char)); + return (val); + } + + SBE_NODISCARD ExecTypTrdCxl::Value execType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(char)); + return ExecTypTrdCxl::get((val)); + } + + ExecutionReportTradeAddendumSpreadLeg550 &execType(const ExecTypTrdCxl::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 172, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= manualOrderIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 173; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 173, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } + + ExecutionReportTradeAddendumSpreadLeg550 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 173, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= possRetransFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 174; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 174, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportTradeAddendumSpreadLeg550 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 174, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 175; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 5) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value side() const + { + if (m_actingVersion < 5) + { + return SideReq::NULL_VALUE; + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 175, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + ExecutionReportTradeAddendumSpreadLeg550 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 175, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SettlDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t settlDateId() SBE_NOEXCEPT + { + return 64; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlDateSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool settlDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= settlDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlDateEncodingOffset() SBE_NOEXCEPT + { + return 176; + } + + static SBE_CONSTEXPR std::uint16_t settlDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t settlDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t settlDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t settlDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t settlDate() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } + + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 176, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeAddendumSpreadLeg550 &settlDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 176, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *CalculatedCcyLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t calculatedCcyLastQtyId() SBE_NOEXCEPT + { + return 1056; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t calculatedCcyLastQtySinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool calculatedCcyLastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= calculatedCcyLastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t calculatedCcyLastQtyEncodingOffset() SBE_NOEXCEPT + { + return 178; + } + +private: + Decimal64NULL m_calculatedCcyLastQty; + +public: + SBE_NODISCARD Decimal64NULL &calculatedCcyLastQty() + { + m_calculatedCcyLastQty.wrap(m_buffer, m_offset + 178, m_actingVersion, m_bufferLength); + return m_calculatedCcyLastQty; + } + + SBE_NODISCARD static const char *GrossTradeAmtMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t grossTradeAmtId() SBE_NOEXCEPT + { + return 381; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t grossTradeAmtSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool grossTradeAmtInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= grossTradeAmtSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t grossTradeAmtEncodingOffset() SBE_NOEXCEPT + { + return 187; + } + +private: + Decimal64NULL m_grossTradeAmt; + +public: + SBE_NODISCARD Decimal64NULL &grossTradeAmt() + { + m_grossTradeAmt.wrap(m_buffer, m_offset + 187, m_actingVersion, m_bufferLength); + return m_grossTradeAmt; + } + + class NoFills + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(15)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 15; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 15; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoFills &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT + { + return 1364; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_fillPx; + +public: + SBE_NODISCARD PRICE9 &fillPx() + { + m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_fillPx; + } + + SBE_NODISCARD static const char *FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT + { + return 1365; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillQtyEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT + { + return 1363; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillExecIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char fillExecID(const std::uint64_t index) const + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } + + NoFills &fillExecID(const std::uint64_t index, const char value) + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getFillExecID(char *const dst, const std::uint64_t length) const + { + if (length > 2) + { + throw std::runtime_error("length too large for getFillExecID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } + + NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); + return *this; + } + + NoFills &putFillExecID( + const char value0, + const char value1) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getFillExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getFillExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getFillExecIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getFillExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoFills &putFillExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #else + NoFills &putFillExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *FillYieldTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT + { + return 1622; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillYieldTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillYieldTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingOffset() SBE_NOEXCEPT + { + return 14; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return (val); + } + + NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoFills writer) + { + builder << '{'; + builder << R"("FillPx": )"; + builder << writer.fillPx(); + + builder << ", "; + builder << R"("FillQty": )"; + builder << +writer.fillQty(); + + builder << ", "; + builder << R"("FillExecID": )"; + builder << '"' << + writer.getFillExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("FillYieldType": )"; + builder << +writer.fillYieldType(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)27); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 27; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoFills m_noFills; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 27; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT + { + return 1362; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoFills &noFills() + { + m_noFills.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoFills &noFillsCount(const std::uint8_t count) + { + m_noFills.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noFillsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoOrderEvents &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *OrderEventPxMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT { - return 1799; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderEventPxSinceVersion(); + return m_actingVersion >= noFillsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoOrderEvents + { private: - PRICE9 m_orderEventPx; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; + + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - SBE_NODISCARD PRICE9 &orderEventPx() { - m_orderEventPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_orderEventPx; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - SBE_NODISCARD static const char *OrderEventTextMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT { - return 1802; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTextSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTextSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTextEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - orderEventTextEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char orderEventText(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); - return (val); - } - - NoOrderEvents & - orderEventText(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getOrderEventText(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error( - "length too large for getOrderEventText [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 8, - sizeof(char) * static_cast(length)); - return length; - } - - NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getOrderEventTextAsString() const { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getOrderEventTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrderEventTextAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getOrderEventTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoOrderEvents &putOrderEventText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } - - return *this; - } -#else - NoOrderEvents &putOrderEventText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT { - return 1797; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingOffset() SBE_NOEXCEPT { - return 13; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT { - return 1800; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT { - return 1796; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD TradeAddendum::Value orderEventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); - return TradeAddendum::get((val)); - } - - NoOrderEvents & - orderEventType(const TradeAddendum::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT { - return 1798; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingOffset() SBE_NOEXCEPT { - return 22; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); - return (val); - } - - NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *OriginalOrderEventExecIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - originalOrderEventExecIDId() SBE_NOEXCEPT { - return 6555; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - originalOrderEventExecIDSinceVersion() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD bool - originalOrderEventExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= originalOrderEventExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - originalOrderEventExecIDEncodingOffset() SBE_NOEXCEPT { - return 23; - } - - static SBE_CONSTEXPR std::uint32_t - originalOrderEventExecIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t - originalOrderEventExecIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t - originalOrderEventExecIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - originalOrderEventExecIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t - originalOrderEventExecID() const SBE_NOEXCEPT { - if (m_actingVersion < 3) { - return 4294967295; - } - - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents & - originalOrderEventExecID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint32_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderEvents writer) { - builder << '{'; - builder << R"("OrderEventPx": )"; - builder << writer.orderEventPx(); - - builder << ", "; - builder << R"("OrderEventText": )"; - builder << '"' << writer.getOrderEventTextAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("OrderEventExecID": )"; - builder << +writer.orderEventExecID(); - - builder << ", "; - builder << R"("OrderEventQty": )"; - builder << +writer.orderEventQty(); - - builder << ", "; - builder << R"("OrderEventType": )"; - builder << '"' << writer.orderEventType() << '"'; - - builder << ", "; - builder << R"("OrderEventReason": )"; - builder << +writer.orderEventReason(); - - builder << ", "; - builder << R"("OriginalOrderEventExecID": )"; - builder << +writer.originalOrderEventExecID(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(27)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 27; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 27; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoOrderEvents &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *OrderEventPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT + { + return 1799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_orderEventPx; + +public: + SBE_NODISCARD PRICE9 &orderEventPx() + { + m_orderEventPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_orderEventPx; + } + + SBE_NODISCARD static const char *OrderEventTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT + { + return 1802; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTextSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTextSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTextEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t orderEventTextEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } + + SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } + + SBE_NODISCARD char orderEventText(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); + return (val); + } + + NoOrderEvents &orderEventText(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrderEventText(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getOrderEventText [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 8, sizeof(char) * static_cast(length)); + return length; + } + + NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getOrderEventTextAsString() const + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrderEventTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrderEventTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrderEventTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoOrderEvents &putOrderEventText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } + + return *this; + } + #else + NoOrderEvents &putOrderEventText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT + { + return 1797; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingOffset() SBE_NOEXCEPT + { + return 13; + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT + { + return 1800; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventQtyEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT + { + return 1796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD TradeAddendum::Value orderEventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return TradeAddendum::get((val)); + } + + NoOrderEvents &orderEventType(const TradeAddendum::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT + { + return 1798; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventReasonEncodingOffset() SBE_NOEXCEPT + { + return 22; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t orderEventReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); + return (val); + } + + NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OriginalOrderEventExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t originalOrderEventExecIDId() SBE_NOEXCEPT + { + return 6555; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t originalOrderEventExecIDSinceVersion() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD bool originalOrderEventExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= originalOrderEventExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t originalOrderEventExecIDEncodingOffset() SBE_NOEXCEPT + { + return 23; + } + + static SBE_CONSTEXPR std::uint32_t originalOrderEventExecIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t originalOrderEventExecIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t originalOrderEventExecIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t originalOrderEventExecIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t originalOrderEventExecID() const SBE_NOEXCEPT + { + if (m_actingVersion < 3) + { + return UINT32_C(0xffffffff); + } + + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &originalOrderEventExecID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint32_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoOrderEvents writer) + { + builder << '{'; + builder << R"("OrderEventPx": )"; + builder << writer.orderEventPx(); + + builder << ", "; + builder << R"("OrderEventText": )"; + builder << '"' << + writer.getOrderEventTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("OrderEventExecID": )"; + builder << +writer.orderEventExecID(); + + builder << ", "; + builder << R"("OrderEventQty": )"; + builder << +writer.orderEventQty(); + + builder << ", "; + builder << R"("OrderEventType": )"; + builder << '"' << writer.orderEventType() << '"'; + + builder << ", "; + builder << R"("OrderEventReason": )"; + builder << +writer.orderEventReason(); + + builder << ", "; + builder << R"("OriginalOrderEventExecID": )"; + builder << +writer.originalOrderEventExecID(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoOrderEvents m_noOrderEvents; +private: + NoOrderEvents m_noOrderEvents; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderEventsId() SBE_NOEXCEPT { - return 1795; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderEventsId() SBE_NOEXCEPT + { + return 1795; + } - SBE_NODISCARD inline NoOrderEvents &noOrderEvents() { - m_noOrderEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } + SBE_NODISCARD inline NoOrderEvents &noOrderEvents() + { + m_noOrderEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - NoOrderEvents &noOrderEventsCount(const std::uint8_t count) { - m_noOrderEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } + NoOrderEvents &noOrderEventsCount(const std::uint8_t count) + { + m_noOrderEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderEventsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noOrderEventsSinceVersion(); + return m_actingVersion >= noOrderEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportTradeAddendumSpreadLeg550 _writer) { - ExecutionReportTradeAddendumSpreadLeg550 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportTradeAddendumSpreadLeg550", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportTradeAddendumSpreadLeg550 _writer) +{ + ExecutionReportTradeAddendumSpreadLeg550 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << '{'; + builder << R"("Name": "ExecutionReportTradeAddendumSpreadLeg550", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("LastPx": )"; - builder << writer.lastPx(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + builder << ", "; + builder << R"("LastPx": )"; + builder << writer.lastPx(); - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("SecExecID": )"; - builder << +writer.secExecID(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("OrigSecondaryExecutionID": )"; - builder << +writer.origSecondaryExecutionID(); + builder << ", "; + builder << R"("SecExecID": )"; + builder << +writer.secExecID(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("OrigSecondaryExecutionID": )"; + builder << +writer.origSecondaryExecutionID(); - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("LastQty": )"; - builder << +writer.lastQty(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("SideTradeID": )"; - builder << +writer.sideTradeID(); + builder << ", "; + builder << R"("LastQty": )"; + builder << +writer.lastQty(); - builder << ", "; - builder << R"("OrigSideTradeID": )"; - builder << +writer.origSideTradeID(); + builder << ", "; + builder << R"("SideTradeID": )"; + builder << +writer.sideTradeID(); - builder << ", "; - builder << R"("TradeDate": )"; - builder << +writer.tradeDate(); + builder << ", "; + builder << R"("OrigSideTradeID": )"; + builder << +writer.origSideTradeID(); - builder << ", "; - builder << R"("OrdStatus": )"; - builder << '"' << writer.ordStatus() << '"'; + builder << ", "; + builder << R"("TradeDate": )"; + builder << +writer.tradeDate(); - builder << ", "; - builder << R"("ExecType": )"; - builder << '"' << writer.execType() << '"'; + builder << ", "; + builder << R"("OrdStatus": )"; + builder << '"' << writer.ordStatus() << '"'; - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("ExecType": )"; + builder << '"' << writer.execType() << '"'; - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoFills": [)"; - writer.noFills().forEach([&](NoFills &noFills) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noFills; - }); - builder << ']'; - } + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderEvents": [)"; - writer.noOrderEvents().forEach([&](NoOrderEvents &noOrderEvents) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderEvents; - }); - builder << ']'; - } + builder << ", "; + builder << R"("SettlDate": )"; + builder << +writer.settlDate(); - builder << '}'; + builder << ", "; + builder << R"("CalculatedCcyLastQty": )"; + if (writer.calculatedCcyLastQtyInActingVersion()) + { + builder << writer.calculatedCcyLastQty(); + } + else + { + builder << "{}"; + } - return builder; - } + builder << ", "; + builder << R"("GrossTradeAmt": )"; + if (writer.grossTradeAmtInActingVersion()) + { + builder << writer.grossTradeAmt(); + } + else + { + builder << "{}"; + } - void skip() { - noFills().forEach([](NoFills e) { e.skip(); }); - noOrderEvents().forEach([](NoOrderEvents e) { e.skip(); }); - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoFills": [)"; + writer.noFills().forEach( + [&](NoFills &noFills) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noFills; + }); + builder << ']'; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderEvents": [)"; + writer.noOrderEvents().forEach( + [&](NoOrderEvents &noOrderEvents) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderEvents; + }); + builder << ']'; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoFillsLength = 0, std::size_t NoOrderEventsLength = 0) { + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noFillsGroup { noFills() }; + while (noFillsGroup.hasNext()) + { + noFillsGroup.next().skip(); + } + auto &noOrderEventsGroup { noOrderEvents() }; + while (noOrderEventsGroup.hasNext()) + { + noOrderEventsGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noFillsLength = 0, + std::size_t noOrderEventsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoFills::sbeHeaderSize(); - if (NoFillsLength > 254) { - throw std::runtime_error( - "NoFillsLength outside of allowed range [E110]"); - } - length += NoFillsLength * NoFills::sbeBlockLength(); + length += NoFills::sbeHeaderSize(); + if (noFillsLength > 254LL) + { + throw std::runtime_error("noFillsLength outside of allowed range [E110]"); + } + length += noFillsLength *NoFills::sbeBlockLength(); - length += NoOrderEvents::sbeHeaderSize(); - if (NoOrderEventsLength > 254) { - throw std::runtime_error( - "NoOrderEventsLength outside of allowed range [E110]"); - } - length += NoOrderEventsLength * NoOrderEvents::sbeBlockLength(); - return length; + length += NoOrderEvents::sbeHeaderSize(); + if (noOrderEventsLength > 254LL) + { + throw std::runtime_error("noOrderEventsLength outside of allowed range [E110]"); + } + length += noOrderEventsLength *NoOrderEvents::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportTradeOutright525.h b/src/lib/orderman/ilink3/generated/ExecutionReportTradeOutright525.h index ae25e4389..367d42400 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportTradeOutright525.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportTradeOutright525.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,4930 +86,6202 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportTradeOutright525 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - ExecutionReportTradeOutright525() = default; - - ExecutionReportTradeOutright525( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - ExecutionReportTradeOutright525( - char *buffer, const std::uint64_t bufferLength) - : ExecutionReportTradeOutright525( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - ExecutionReportTradeOutright525( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportTradeOutright525( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)235; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)525; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - ExecutionReportTradeOutright525 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeOutright525( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - ExecutionReportTradeOutright525 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = ExecutionReportTradeOutright525( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - ExecutionReportTradeOutright525 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeOutright525( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportTradeOutright525 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeOutright525 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= uUIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeOutright525 & - uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } - - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } - - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeOutright525 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeOutright525 & - putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } - - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeOutright525 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeOutright525 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeOutright525 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeOutright525 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeOutright525 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeOutright525 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= clOrdIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } - - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeOutright525 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeOutright525 & - putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeOutright525 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeOutright525 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 92; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeOutright525 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT { return 31; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastPxEncodingOffset() SBE_NOEXCEPT { - return 100; - } - - private: - PRICE9 m_lastPx; - - public: - SBE_NODISCARD PRICE9 &lastPx() { - m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); - return m_lastPx; - } - - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 108; - } - - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeOutright525 & - orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= priceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 116; - } - - private: - PRICE9 m_price; - - public: - SBE_NODISCARD PRICE9 &price() { - m_price.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); - return m_price; - } - - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= stopPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 124; - } - - private: - PRICENULL9 m_stopPx; - - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 124, m_actingVersion, m_bufferLength); - return m_stopPx; - } - - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= transactTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 132; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeOutright525 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 140; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeOutright525 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderRequestIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 148; - } - - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeOutright525 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT { return 527; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - secExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= secExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - secExecIDEncodingOffset() SBE_NOEXCEPT { - return 156; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeOutright525 & - secExecID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT { return 548; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= crossIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossIDEncodingOffset() SBE_NOEXCEPT { - return 164; - } - - static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 164, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeOutright525 & - crossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 164, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT { - return 961; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hostCrossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= hostCrossIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hostCrossIDEncodingOffset() SBE_NOEXCEPT { - return 172; - } - - static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 172, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeOutright525 & - hostCrossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 172, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 180; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 180; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 180; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 180 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeOutright525 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 180 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 180, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeOutright525 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 180, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 180; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 180; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeOutright525 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 180, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 180 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeOutright525 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 180, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 180 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 185; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeOutright525 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 189; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeOutright525 & - orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT { return 32; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastQtyEncodingOffset() SBE_NOEXCEPT { - return 193; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeOutright525 & - lastQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT { return 14; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cumQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= cumQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cumQtyEncodingOffset() SBE_NOEXCEPT { - return 197; - } - - static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeOutright525 & - cumQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 197, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDTradeEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDTradeEntryIDId() SBE_NOEXCEPT { - return 37711; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDTradeEntryIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDTradeEntryIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDTradeEntryIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingOffset() SBE_NOEXCEPT { - return 201; - } - - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t mDTradeEntryID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeOutright525 & - mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT { - return 1506; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideTradeIDEncodingOffset() SBE_NOEXCEPT { - return 205; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 205, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeOutright525 & - sideTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 205, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - TradeLinkIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t tradeLinkIDId() SBE_NOEXCEPT { - return 820; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradeLinkIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradeLinkIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradeLinkIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeLinkIDEncodingOffset() SBE_NOEXCEPT { - return 209; - } - - static SBE_CONSTEXPR std::uint32_t tradeLinkIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t tradeLinkIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t tradeLinkIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t tradeLinkIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t tradeLinkID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 209, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeOutright525 & - tradeLinkID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 209, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT { return 151; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - leavesQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= leavesQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - leavesQtyEncodingOffset() SBE_NOEXCEPT { - return 213; - } - - static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 213, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeOutright525 & - leavesQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 213, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT { return 75; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradeDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradeDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeDateEncodingOffset() SBE_NOEXCEPT { - return 217; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 217, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - ExecutionReportTradeOutright525 & - tradeDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 217, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= expireDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 219; - } - - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 219, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - ExecutionReportTradeOutright525 & - expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 219, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordStatusSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 221; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrdStatusTrd::Value ordStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 221, sizeof(std::uint8_t)); - return OrdStatusTrd::get((val)); - } - - ExecutionReportTradeOutright525 & - ordStatus(const OrdStatusTrd::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 221, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 222; - } - - static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *execType() const { - static const std::uint8_t execTypeValues[] = {70}; - - return (const char *)execTypeValues; - } - - SBE_NODISCARD char execType(const std::uint64_t index) const { - static const std::uint8_t execTypeValues[] = {70}; - - return (char)execTypeValues[index]; - } - - std::uint64_t getExecType(char *dst, const std::uint64_t length) const { - static std::uint8_t execTypeValues[] = {70}; - std::uint64_t bytesToCopy = - length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); - - std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getExecTypeAsString() const { - static const std::uint8_t ExecTypeValues[] = {70}; - - return std::string((const char *)ExecTypeValues, 1); - } - - std::string getExecTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecTypeAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 222; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 222, sizeof(char)); - return OrderType::get((val)); - } - - ExecutionReportTradeOutright525 & - ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 222, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 223; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 223, sizeof(std::uint8_t)); - return SideReq::get((val)); - } - - ExecutionReportTradeOutright525 & - side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 223, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= timeInForceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 224; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 224, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } - - ExecutionReportTradeOutright525 & - timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 224, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 225; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 225, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - ExecutionReportTradeOutright525 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 225, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= possRetransFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 226; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 226, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - ExecutionReportTradeOutright525 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 226, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *AggressorIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t aggressorIndicatorId() SBE_NOEXCEPT { - return 1057; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - aggressorIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool aggressorIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= aggressorIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - aggressorIndicatorEncodingOffset() SBE_NOEXCEPT { - return 227; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - aggressorIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value aggressorIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 227, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - ExecutionReportTradeOutright525 & - aggressorIndicator(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 227, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT { return 549; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= crossTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossTypeEncodingOffset() SBE_NOEXCEPT { - return 228; - } - - static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } - - static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 228, sizeof(std::uint8_t)); - return (val); - } - - ExecutionReportTradeOutright525 & - crossType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 228, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execInstSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 229; - } - - private: - ExecInst m_execInst; - - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 229, m_actingVersion, m_bufferLength); - return m_execInst; - } - - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= executionModeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 230; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 230, sizeof(char)); - return ExecMode::get((val)); - } - - ExecutionReportTradeOutright525 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 230, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= liquidityFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 231; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 231, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - ExecutionReportTradeOutright525 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 231, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= managedOrderSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 232; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 232, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - ExecutionReportTradeOutright525 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 232, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= shortSaleTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 233; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 233, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } - - ExecutionReportTradeOutright525 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 233, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - OwnershipMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ownershipId() SBE_NOEXCEPT { - return 7191; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ownershipSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ownershipInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ownershipSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ownershipEncodingOffset() SBE_NOEXCEPT { - return 234; - } - - static SBE_CONSTEXPR std::uint8_t ownershipNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t ownershipMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t ownershipMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t ownershipEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t ownership() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 234, sizeof(std::uint8_t)); - return (val); - } - - ExecutionReportTradeOutright525 & - ownership(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 234, &val, sizeof(std::uint8_t)); - return *this; - } - - class NoFills { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)15); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 15; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 15; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { +class ExecutionReportTradeOutright525 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(293); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(525); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + ExecutionReportTradeOutright525() = default; + + ExecutionReportTradeOutright525( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + ExecutionReportTradeOutright525(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportTradeOutright525(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + ExecutionReportTradeOutright525( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportTradeOutright525(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(293); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(525); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + ExecutionReportTradeOutright525 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeOutright525(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + ExecutionReportTradeOutright525 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = ExecutionReportTradeOutright525( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + ExecutionReportTradeOutright525 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeOutright525(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + ExecutionReportTradeOutright525 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + } + return position; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportTradeOutright525 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoFills &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - return *this; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD static const char * - FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT { - return 1364; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillPxSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICE9 m_fillPx; + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - public: - SBE_NODISCARD PRICE9 &fillPx() { - m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_fillPx; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - SBE_NODISCARD static const char * - FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT { - return 1365; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT { + ExecutionReportTradeOutright525 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillQtySinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportTradeOutright525 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT { - return 1363; - } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillExecIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillExecIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char fillExecID(const std::uint64_t index) const { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy( - &val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - NoFills &fillExecID(const std::uint64_t index, const char value) { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E105]"); - } + ExecutionReportTradeOutright525 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy( - m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getFillExecID(char *const dst, const std::uint64_t length) const { - if (length > 2) { - throw std::runtime_error( - "length too large for getFillExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); - return *this; - } + ExecutionReportTradeOutright525 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - NoFills & - putFillExecID(const char value0, const char value1) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - return *this; - } + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - SBE_NODISCARD std::string getFillExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + return result; + } - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - return result; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - std::string getFillExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getFillExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getFillExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NoFills &putFillExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportTradeOutright525 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#else - NoFills &putFillExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + return *this; + } + #else + ExecutionReportTradeOutright525 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *FillYieldTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT { - return 1622; - } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillYieldTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillYieldTypeSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return (val); - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoFills writer) { - builder << '{'; - builder << R"("FillPx": )"; - builder << writer.fillPx(); + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - builder << ", "; - builder << R"("FillQty": )"; - builder << +writer.fillQty(); + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - builder << ", "; - builder << R"("FillExecID": )"; - builder << '"' << writer.getFillExecIDAsJsonEscapedString().c_str() - << '"'; + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - builder << ", "; - builder << R"("FillYieldType": )"; - builder << +writer.fillYieldType(); + ExecutionReportTradeOutright525 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - builder << '}'; + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - return builder; - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - void skip() {} + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + ExecutionReportTradeOutright525 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - private: - NoFills m_noFills; + return result; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT { - return 1362; - } + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - SBE_NODISCARD inline NoFills &noFills() { - m_noFills.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - NoFills &noFillsCount(const std::uint8_t count) { - m_noFills.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noFillsSinceVersion() SBE_NOEXCEPT { - return 0; - } + return oss.str(); + } - SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT { + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeOutright525 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeOutright525 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noFillsSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoOrderEvents { + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } + + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeOutright525 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeOutright525 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeOutright525 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeOutright525 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeOutright525 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT + { + return 31; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastPxSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastPxEncodingOffset() SBE_NOEXCEPT + { + return 100; + } + +private: + PRICE9 m_lastPx; + +public: + SBE_NODISCARD PRICE9 &lastPx() + { + m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); + return m_lastPx; + } + + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 108; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeOutright525 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 116; + } + +private: + PRICE9 m_price; + +public: + SBE_NODISCARD PRICE9 &price() + { + m_price.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); + return m_price; + } + + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= stopPxSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 124; + } + +private: + PRICENULL9 m_stopPx; + +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 124, m_actingVersion, m_bufferLength); + return m_stopPx; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= transactTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 132; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeOutright525 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 140; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeOutright525 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderRequestIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 148; + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeOutright525 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT + { + return 527; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t secExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= secExecIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t secExecIDEncodingOffset() SBE_NOEXCEPT + { + return 156; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeOutright525 &secExecID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT + { + return 548; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= crossIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossIDEncodingOffset() SBE_NOEXCEPT + { + return 164; + } + + static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 164, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeOutright525 &crossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 164, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT + { + return 961; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hostCrossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= hostCrossIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hostCrossIDEncodingOffset() SBE_NOEXCEPT + { + return 172; + } + + static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeOutright525 &hostCrossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 172, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 180; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 180; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 180; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 180 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeOutright525 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 180 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 180, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeOutright525 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 180, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 180; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 180; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeOutright525 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 180, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 180 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeOutright525 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 180, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 180 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 185; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeOutright525 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 189; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeOutright525 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT + { + return 32; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastQtyEncodingOffset() SBE_NOEXCEPT + { + return 193; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeOutright525 &lastQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT + { + return 14; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cumQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cumQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cumQtyEncodingOffset() SBE_NOEXCEPT + { + return 197; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeOutright525 &cumQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 197, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *MDTradeEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDTradeEntryIDId() SBE_NOEXCEPT + { + return 37711; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDTradeEntryIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDTradeEntryIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= mDTradeEntryIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDTradeEntryIDEncodingOffset() SBE_NOEXCEPT + { + return 201; + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t mDTradeEntryIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t mDTradeEntryID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeOutright525 &mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT + { + return 1506; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideTradeIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 205; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 205, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeOutright525 &sideTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 205, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *TradeLinkIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t tradeLinkIDId() SBE_NOEXCEPT + { + return 820; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradeLinkIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradeLinkIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= tradeLinkIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeLinkIDEncodingOffset() SBE_NOEXCEPT + { + return 209; + } + + static SBE_CONSTEXPR std::uint32_t tradeLinkIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t tradeLinkIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t tradeLinkIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t tradeLinkIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t tradeLinkID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 209, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeOutright525 &tradeLinkID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 209, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT + { + return 151; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t leavesQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= leavesQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t leavesQtyEncodingOffset() SBE_NOEXCEPT + { + return 213; + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 213, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeOutright525 &leavesQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 213, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT + { + return 75; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradeDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= tradeDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeDateEncodingOffset() SBE_NOEXCEPT + { + return 217; + } + + static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 217, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeOutright525 &tradeDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 217, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= expireDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 219; + } + + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 219, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeOutright525 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 219, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordStatusSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 221; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t ordStatusRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 221, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD OrdStatusTrd::Value ordStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 221, sizeof(std::uint8_t)); + return OrdStatusTrd::get((val)); + } + + ExecutionReportTradeOutright525 &ordStatus(const OrdStatusTrd::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 221, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 222; + } + + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 70, 0 }; + + return (const char *)execTypeValues; + } + + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 70, 0 }; + + return (char)execTypeValues[index]; + } + + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 70 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 70 }; + + return std::string((const char *)ExecTypeValues, 1); + } + + std::string getExecTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 222; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 222, sizeof(char)); + return (val); + } + + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 222, sizeof(char)); + return OrderType::get((val)); + } + + ExecutionReportTradeOutright525 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 222, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 223; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 223, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 223, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + ExecutionReportTradeOutright525 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 223, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= timeInForceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 224; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 224, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 224, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } + + ExecutionReportTradeOutright525 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 224, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= manualOrderIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 225; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 225, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 225, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } + + ExecutionReportTradeOutright525 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 225, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= possRetransFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 226; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 226, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 226, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportTradeOutright525 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 226, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *AggressorIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t aggressorIndicatorId() SBE_NOEXCEPT + { + return 1057; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t aggressorIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool aggressorIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= aggressorIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t aggressorIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 227; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t aggressorIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t aggressorIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 227, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value aggressorIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 227, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportTradeOutright525 &aggressorIndicator(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 227, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT + { + return 549; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= crossTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossTypeEncodingOffset() SBE_NOEXCEPT + { + return 228; + } + + static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 228, sizeof(std::uint8_t)); + return (val); + } + + ExecutionReportTradeOutright525 &crossType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 228, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execInstSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 229; + } + +private: + ExecInst m_execInst; + +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 229, m_actingVersion, m_bufferLength); + return m_execInst; + } + + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= executionModeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 230; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 230, sizeof(char)); + return (val); + } + + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 230, sizeof(char)); + return ExecMode::get((val)); + } + + ExecutionReportTradeOutright525 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 230, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= liquidityFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 231; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 231, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 231, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + ExecutionReportTradeOutright525 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 231, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= managedOrderSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 232; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 232, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 232, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + ExecutionReportTradeOutright525 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 232, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= shortSaleTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 233; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 233, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 233, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } + + ExecutionReportTradeOutright525 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 233, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OwnershipMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ownershipId() SBE_NOEXCEPT + { + return 7191; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ownershipSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ownershipInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ownershipSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ownershipEncodingOffset() SBE_NOEXCEPT + { + return 234; + } + + static SBE_CONSTEXPR std::uint8_t ownershipNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t ownershipMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t ownershipMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t ownershipEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t ownership() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 234, sizeof(std::uint8_t)); + return (val); + } + + ExecutionReportTradeOutright525 &ownership(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 234, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 235; + } + +private: + PRICENULL9 m_discretionPrice; + +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 235, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } + + SBE_NODISCARD static const char *TrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t trdTypeId() SBE_NOEXCEPT + { + return 828; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t trdTypeSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool trdTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= trdTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t trdTypeEncodingOffset() SBE_NOEXCEPT + { + return 243; + } + + static SBE_CONSTEXPR std::uint16_t trdTypeNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t trdTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t trdTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t trdTypeEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t trdType() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } + + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 243, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeOutright525 &trdType(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 243, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecRestatementReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execRestatementReasonId() SBE_NOEXCEPT + { + return 378; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execRestatementReasonSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool execRestatementReasonInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execRestatementReasonSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execRestatementReasonEncodingOffset() SBE_NOEXCEPT + { + return 245; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execRestatementReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t execRestatementReasonRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 245, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ExecReason::Value execRestatementReason() const + { + if (m_actingVersion < 6) + { + return ExecReason::NULL_VALUE; + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 245, sizeof(std::uint8_t)); + return ExecReason::get((val)); + } + + ExecutionReportTradeOutright525 &execRestatementReason(const ExecReason::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 245, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SettlDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t settlDateId() SBE_NOEXCEPT + { + return 64; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlDateSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool settlDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= settlDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlDateEncodingOffset() SBE_NOEXCEPT + { + return 246; + } + + static SBE_CONSTEXPR std::uint16_t settlDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t settlDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t settlDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t settlDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t settlDate() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } + + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 246, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeOutright525 &settlDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 246, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *MaturityDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t maturityDateId() SBE_NOEXCEPT + { + return 541; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maturityDateSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool maturityDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= maturityDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maturityDateEncodingOffset() SBE_NOEXCEPT + { + return 248; + } + + static SBE_CONSTEXPR std::uint16_t maturityDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t maturityDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t maturityDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t maturityDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t maturityDate() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } + + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 248, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeOutright525 &maturityDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 248, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *CalculatedCcyLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t calculatedCcyLastQtyId() SBE_NOEXCEPT + { + return 1056; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t calculatedCcyLastQtySinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool calculatedCcyLastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= calculatedCcyLastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t calculatedCcyLastQtyEncodingOffset() SBE_NOEXCEPT + { + return 250; + } + +private: + Decimal64NULL m_calculatedCcyLastQty; + +public: + SBE_NODISCARD Decimal64NULL &calculatedCcyLastQty() + { + m_calculatedCcyLastQty.wrap(m_buffer, m_offset + 250, m_actingVersion, m_bufferLength); + return m_calculatedCcyLastQty; + } + + SBE_NODISCARD static const char *GrossTradeAmtMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t grossTradeAmtId() SBE_NOEXCEPT + { + return 381; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t grossTradeAmtSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool grossTradeAmtInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= grossTradeAmtSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t grossTradeAmtEncodingOffset() SBE_NOEXCEPT + { + return 259; + } + +private: + Decimal64NULL m_grossTradeAmt; + +public: + SBE_NODISCARD Decimal64NULL &grossTradeAmt() + { + m_grossTradeAmt.wrap(m_buffer, m_offset + 259, m_actingVersion, m_bufferLength); + return m_grossTradeAmt; + } + + SBE_NODISCARD static const char *BenchmarkPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t benchmarkPriceId() SBE_NOEXCEPT + { + return 6262; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t benchmarkPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool benchmarkPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= benchmarkPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t benchmarkPriceEncodingOffset() SBE_NOEXCEPT + { + return 268; + } + +private: + PRICENULL9 m_benchmarkPrice; + +public: + SBE_NODISCARD PRICENULL9 &benchmarkPrice() + { + m_benchmarkPrice.wrap(m_buffer, m_offset + 268, m_actingVersion, m_bufferLength); + return m_benchmarkPrice; + } + + SBE_NODISCARD static const char *ReservationPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t reservationPriceId() SBE_NOEXCEPT + { + return 9562; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reservationPriceSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool reservationPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reservationPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reservationPriceEncodingOffset() SBE_NOEXCEPT + { + return 276; + } + +private: + PRICENULL9 m_reservationPrice; + +public: + SBE_NODISCARD PRICENULL9 &reservationPrice() + { + m_reservationPrice.wrap(m_buffer, m_offset + 276, m_actingVersion, m_bufferLength); + return m_reservationPrice; + } + + SBE_NODISCARD static const char *PriorityIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t priorityIndicatorId() SBE_NOEXCEPT + { + return 638; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priorityIndicatorSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool priorityIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priorityIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 284; + } + + static SBE_CONSTEXPR std::uint8_t priorityIndicatorNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t priorityIndicatorMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t priorityIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t priorityIndicator() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 284, sizeof(std::uint8_t)); + return (val); + } + + ExecutionReportTradeOutright525 &priorityIndicator(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 284, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *DisplayLimitPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t displayLimitPriceId() SBE_NOEXCEPT + { + return 9264; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool displayLimitPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= displayLimitPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 285; + } + +private: + PRICENULL9 m_displayLimitPrice; + +public: + SBE_NODISCARD PRICENULL9 &displayLimitPrice() + { + m_displayLimitPrice.wrap(m_buffer, m_offset + 285, m_actingVersion, m_bufferLength); + return m_displayLimitPrice; + } + + class NoFills + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(15)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 15; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 15; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoFills &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT + { + return 1364; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_fillPx; + +public: + SBE_NODISCARD PRICE9 &fillPx() + { + m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_fillPx; + } + + SBE_NODISCARD static const char *FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT + { + return 1365; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillQtyEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT + { + return 1363; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillExecIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char fillExecID(const std::uint64_t index) const + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } + + NoFills &fillExecID(const std::uint64_t index, const char value) + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getFillExecID(char *const dst, const std::uint64_t length) const + { + if (length > 2) + { + throw std::runtime_error("length too large for getFillExecID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } + + NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); + return *this; + } + + NoFills &putFillExecID( + const char value0, + const char value1) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getFillExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getFillExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getFillExecIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getFillExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoFills &putFillExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #else + NoFills &putFillExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *FillYieldTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT + { + return 1622; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillYieldTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillYieldTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingOffset() SBE_NOEXCEPT + { + return 14; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return (val); + } + + NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoFills writer) + { + builder << '{'; + builder << R"("FillPx": )"; + builder << writer.fillPx(); + + builder << ", "; + builder << R"("FillQty": )"; + builder << +writer.fillQty(); + + builder << ", "; + builder << R"("FillExecID": )"; + builder << '"' << + writer.getFillExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("FillYieldType": )"; + builder << +writer.fillYieldType(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)23); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 23; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoFills m_noFills; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 23; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT + { + return 1362; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoFills &noFills() + { + m_noFills.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoFills &noFillsCount(const std::uint8_t count) + { + m_noFills.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noFillsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoOrderEvents &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *OrderEventPxMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT { - return 1799; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderEventPxSinceVersion(); + return m_actingVersion >= noFillsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoOrderEvents + { private: - PRICE9 m_orderEventPx; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; + + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - SBE_NODISCARD PRICE9 &orderEventPx() { - m_orderEventPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_orderEventPx; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - SBE_NODISCARD static const char *OrderEventTextMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT { - return 1802; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTextSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTextSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTextEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - orderEventTextEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char orderEventText(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); - return (val); - } - - NoOrderEvents & - orderEventText(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getOrderEventText(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error( - "length too large for getOrderEventText [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 8, - sizeof(char) * static_cast(length)); - return length; - } - - NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getOrderEventTextAsString() const { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getOrderEventTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrderEventTextAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(41)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 41; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - return oss.str(); - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getOrderEventTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 41; + } - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - return result; - } -#endif + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } -#if __cplusplus >= 201703L - NoOrderEvents &putOrderEventText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - return *this; - } -#else - NoOrderEvents &putOrderEventText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } + inline NoOrderEvents &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - return *this; - } -#endif + return *this; + } - SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } - static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT { - return 1797; - } + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD static const char *OrderEventPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingOffset() SBE_NOEXCEPT { - return 13; - } + static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT + { + return 1799; + } - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMinValue() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingLength() SBE_NOEXCEPT { - return 4; - } +private: + PRICE9 m_orderEventPx; - SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } +public: + SBE_NODISCARD PRICE9 &orderEventPx() + { + m_orderEventPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_orderEventPx; + } - NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); - return *this; - } + SBE_NODISCARD static const char *OrderEventTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static const char *OrderEventQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT + { + return 1802; + } - static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT { - return 1800; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTextSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTextSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTextEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingOffset() SBE_NOEXCEPT { - return 17; - } + static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::size_t orderEventTextEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } - NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } - SBE_NODISCARD static const char *OrderEventTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char orderEventText(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E104]"); + } - static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT { - return 1796; - } + char val; + std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); + return (val); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + NoOrderEvents &orderEventText(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E105]"); + } - SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + char val = (value); + std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingOffset() SBE_NOEXCEPT { - return 21; - } + std::uint64_t getOrderEventText(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getOrderEventText [E106]"); + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + std::memcpy(dst, m_buffer + m_offset + 8, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD OrderEventType::Value orderEventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); - return OrderEventType::get((val)); - } + NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); + return *this; + } - NoOrderEvents & - orderEventType(const OrderEventType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD std::string getOrderEventTextAsString() const + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; - SBE_NODISCARD static const char *OrderEventReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT { - return 1798; - } + return result; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + std::string getOrderEventTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrderEventTextAsString(); - SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingOffset() SBE_NOEXCEPT { - return 22; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - static SBE_CONSTEXPR std::uint8_t - orderEventReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + return oss.str(); + } - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrderEventTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } + return result; + } + #endif - SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); - return (val); - } + #if __cplusplus >= 201703L + NoOrderEvents &putOrderEventText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } - NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); - return *this; - } + std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderEvents writer) { - builder << '{'; - builder << R"("OrderEventPx": )"; - builder << writer.orderEventPx(); + return *this; + } + #else + NoOrderEvents &putOrderEventText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } - builder << ", "; - builder << R"("OrderEventText": )"; - builder << '"' << writer.getOrderEventTextAsJsonEscapedString().c_str() - << '"'; + std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } - builder << ", "; - builder << R"("OrderEventExecID": )"; - builder << +writer.orderEventExecID(); + return *this; + } + #endif - builder << ", "; - builder << R"("OrderEventQty": )"; - builder << +writer.orderEventQty(); + SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("OrderEventType": )"; - builder << '"' << writer.orderEventType() << '"'; + static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT + { + return 1797; + } - builder << ", "; - builder << R"("OrderEventReason": )"; - builder << +writer.orderEventReason(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - builder << '}'; + SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - return builder; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingOffset() SBE_NOEXCEPT + { + return 13; + } - void skip() {} + static SBE_CONSTEXPR std::uint32_t orderEventExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT + { + return 1800; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventQtyEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT + { + return 1796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD OrderEventType::Value orderEventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return OrderEventType::get((val)); + } + + NoOrderEvents &orderEventType(const OrderEventType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT + { + return 1798; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventReasonEncodingOffset() SBE_NOEXCEPT + { + return 22; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t orderEventReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); + return (val); + } + + NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ContraGrossTradeAmtMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t contraGrossTradeAmtId() SBE_NOEXCEPT + { + return 5542; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t contraGrossTradeAmtSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool contraGrossTradeAmtInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= contraGrossTradeAmtSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t contraGrossTradeAmtEncodingOffset() SBE_NOEXCEPT + { + return 23; + } + +private: + Decimal64NULL m_contraGrossTradeAmt; + +public: + SBE_NODISCARD Decimal64NULL &contraGrossTradeAmt() + { + m_contraGrossTradeAmt.wrap(m_buffer, m_offset + 23, m_actingVersion, m_bufferLength); + return m_contraGrossTradeAmt; + } + + SBE_NODISCARD static const char *ContraCalculatedCcyLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t contraCalculatedCcyLastQtyId() SBE_NOEXCEPT + { + return 5971; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t contraCalculatedCcyLastQtySinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool contraCalculatedCcyLastQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= contraCalculatedCcyLastQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t contraCalculatedCcyLastQtyEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + +private: + Decimal64NULL m_contraCalculatedCcyLastQty; + +public: + SBE_NODISCARD Decimal64NULL &contraCalculatedCcyLastQty() + { + m_contraCalculatedCcyLastQty.wrap(m_buffer, m_offset + 32, m_actingVersion, m_bufferLength); + return m_contraCalculatedCcyLastQty; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoOrderEvents writer) + { + builder << '{'; + builder << R"("OrderEventPx": )"; + builder << writer.orderEventPx(); + + builder << ", "; + builder << R"("OrderEventText": )"; + builder << '"' << + writer.getOrderEventTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("OrderEventExecID": )"; + builder << +writer.orderEventExecID(); + + builder << ", "; + builder << R"("OrderEventQty": )"; + builder << +writer.orderEventQty(); + + builder << ", "; + builder << R"("OrderEventType": )"; + builder << '"' << writer.orderEventType() << '"'; + + builder << ", "; + builder << R"("OrderEventReason": )"; + builder << +writer.orderEventReason(); + + builder << ", "; + builder << R"("ContraGrossTradeAmt": )"; + if (writer.contraGrossTradeAmtInActingVersion()) + { + builder << writer.contraGrossTradeAmt(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("ContraCalculatedCcyLastQty": )"; + if (writer.contraCalculatedCcyLastQtyInActingVersion()) + { + builder << writer.contraCalculatedCcyLastQty(); + } + else + { + builder << "{}"; + } + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoOrderEvents m_noOrderEvents; +private: + NoOrderEvents m_noOrderEvents; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderEventsId() SBE_NOEXCEPT { - return 1795; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderEventsId() SBE_NOEXCEPT + { + return 1795; + } - SBE_NODISCARD inline NoOrderEvents &noOrderEvents() { - m_noOrderEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } + SBE_NODISCARD inline NoOrderEvents &noOrderEvents() + { + m_noOrderEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - NoOrderEvents &noOrderEventsCount(const std::uint8_t count) { - m_noOrderEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } + NoOrderEvents &noOrderEventsCount(const std::uint8_t count) + { + m_noOrderEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderEventsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noOrderEventsSinceVersion(); + return m_actingVersion >= noOrderEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportTradeOutright525 _writer) { - ExecutionReportTradeOutright525 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportTradeOutright525", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportTradeOutright525 _writer) +{ + ExecutionReportTradeOutright525 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << '{'; + builder << R"("Name": "ExecutionReportTradeOutright525", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("LastPx": )"; - builder << writer.lastPx(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + builder << ", "; + builder << R"("LastPx": )"; + builder << writer.lastPx(); - builder << ", "; - builder << R"("Price": )"; - builder << writer.price(); + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("SecExecID": )"; - builder << +writer.secExecID(); + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); - builder << ", "; - builder << R"("CrossID": )"; - builder << +writer.crossID(); + builder << ", "; + builder << R"("SecExecID": )"; + builder << +writer.secExecID(); - builder << ", "; - builder << R"("HostCrossID": )"; - builder << +writer.hostCrossID(); + builder << ", "; + builder << R"("CrossID": )"; + builder << +writer.crossID(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("HostCrossID": )"; + builder << +writer.hostCrossID(); - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("LastQty": )"; - builder << +writer.lastQty(); + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); - builder << ", "; - builder << R"("CumQty": )"; - builder << +writer.cumQty(); + builder << ", "; + builder << R"("LastQty": )"; + builder << +writer.lastQty(); - builder << ", "; - builder << R"("MDTradeEntryID": )"; - builder << +writer.mDTradeEntryID(); + builder << ", "; + builder << R"("CumQty": )"; + builder << +writer.cumQty(); - builder << ", "; - builder << R"("SideTradeID": )"; - builder << +writer.sideTradeID(); + builder << ", "; + builder << R"("MDTradeEntryID": )"; + builder << +writer.mDTradeEntryID(); - builder << ", "; - builder << R"("TradeLinkID": )"; - builder << +writer.tradeLinkID(); + builder << ", "; + builder << R"("SideTradeID": )"; + builder << +writer.sideTradeID(); - builder << ", "; - builder << R"("LeavesQty": )"; - builder << +writer.leavesQty(); + builder << ", "; + builder << R"("TradeLinkID": )"; + builder << +writer.tradeLinkID(); - builder << ", "; - builder << R"("TradeDate": )"; - builder << +writer.tradeDate(); + builder << ", "; + builder << R"("LeavesQty": )"; + builder << +writer.leavesQty(); - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); + builder << ", "; + builder << R"("TradeDate": )"; + builder << +writer.tradeDate(); - builder << ", "; - builder << R"("OrdStatus": )"; - builder << '"' << writer.ordStatus() << '"'; + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + builder << ", "; + builder << R"("OrdStatus": )"; + builder << '"' << writer.ordStatus() << '"'; - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - builder << ", "; - builder << R"("AggressorIndicator": )"; - builder << '"' << writer.aggressorIndicator() << '"'; + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; - builder << ", "; - builder << R"("CrossType": )"; - builder << +writer.crossType(); + builder << ", "; + builder << R"("AggressorIndicator": )"; + builder << '"' << writer.aggressorIndicator() << '"'; - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + builder << ", "; + builder << R"("CrossType": )"; + builder << +writer.crossType(); - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; - builder << ", "; - builder << R"("Ownership": )"; - builder << +writer.ownership(); + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoFills": [)"; - writer.noFills().forEach([&](NoFills &noFills) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noFills; - }); - builder << ']'; - } + builder << ", "; + builder << R"("Ownership": )"; + builder << +writer.ownership(); - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderEvents": [)"; - writer.noOrderEvents().forEach([&](NoOrderEvents &noOrderEvents) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderEvents; - }); - builder << ']'; - } + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } - builder << '}'; + builder << ", "; + builder << R"("TrdType": )"; + builder << +writer.trdType(); - return builder; - } + builder << ", "; + builder << R"("ExecRestatementReason": )"; + builder << '"' << writer.execRestatementReason() << '"'; - void skip() { - noFills().forEach([](NoFills e) { e.skip(); }); - noOrderEvents().forEach([](NoOrderEvents e) { e.skip(); }); - } + builder << ", "; + builder << R"("SettlDate": )"; + builder << +writer.settlDate(); - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + builder << ", "; + builder << R"("MaturityDate": )"; + builder << +writer.maturityDate(); - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoFillsLength = 0, std::size_t NoOrderEventsLength = 0) { + builder << ", "; + builder << R"("CalculatedCcyLastQty": )"; + if (writer.calculatedCcyLastQtyInActingVersion()) + { + builder << writer.calculatedCcyLastQty(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("GrossTradeAmt": )"; + if (writer.grossTradeAmtInActingVersion()) + { + builder << writer.grossTradeAmt(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("BenchmarkPrice": )"; + if (writer.benchmarkPriceInActingVersion()) + { + builder << writer.benchmarkPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("ReservationPrice": )"; + if (writer.reservationPriceInActingVersion()) + { + builder << writer.reservationPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("PriorityIndicator": )"; + builder << +writer.priorityIndicator(); + + builder << ", "; + builder << R"("DisplayLimitPrice": )"; + if (writer.displayLimitPriceInActingVersion()) + { + builder << writer.displayLimitPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoFills": [)"; + writer.noFills().forEach( + [&](NoFills &noFills) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noFills; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderEvents": [)"; + writer.noOrderEvents().forEach( + [&](NoOrderEvents &noOrderEvents) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderEvents; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noFillsGroup { noFills() }; + while (noFillsGroup.hasNext()) + { + noFillsGroup.next().skip(); + } + auto &noOrderEventsGroup { noOrderEvents() }; + while (noOrderEventsGroup.hasNext()) + { + noOrderEventsGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noFillsLength = 0, + std::size_t noOrderEventsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoFills::sbeHeaderSize(); - if (NoFillsLength > 254) { - throw std::runtime_error( - "NoFillsLength outside of allowed range [E110]"); - } - length += NoFillsLength * NoFills::sbeBlockLength(); + length += NoFills::sbeHeaderSize(); + if (noFillsLength > 254LL) + { + throw std::runtime_error("noFillsLength outside of allowed range [E110]"); + } + length += noFillsLength *NoFills::sbeBlockLength(); - length += NoOrderEvents::sbeHeaderSize(); - if (NoOrderEventsLength > 254) { - throw std::runtime_error( - "NoOrderEventsLength outside of allowed range [E110]"); - } - length += NoOrderEventsLength * NoOrderEvents::sbeBlockLength(); - return length; + length += NoOrderEvents::sbeHeaderSize(); + if (noOrderEventsLength > 254LL) + { + throw std::runtime_error("noOrderEventsLength outside of allowed range [E110]"); + } + length += noOrderEventsLength *NoOrderEvents::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportTradeSpread526.h b/src/lib/orderman/ilink3/generated/ExecutionReportTradeSpread526.h index 4597f0e7a..1784c260f 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportTradeSpread526.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportTradeSpread526.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,5413 +86,5862 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportTradeSpread526 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - ExecutionReportTradeSpread526() = default; - - ExecutionReportTradeSpread526( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - ExecutionReportTradeSpread526(char *buffer, const std::uint64_t bufferLength) - : ExecutionReportTradeSpread526( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - ExecutionReportTradeSpread526( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportTradeSpread526( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)230; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)526; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - ExecutionReportTradeSpread526 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeSpread526( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - ExecutionReportTradeSpread526 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = ExecutionReportTradeSpread526( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - ExecutionReportTradeSpread526 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeSpread526( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportTradeSpread526 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpread526 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= uUIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpread526 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } - - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } - - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeSpread526 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeSpread526 & - putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } - - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeSpread526 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeSpread526 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeSpread526 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeSpread526 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeSpread526 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeSpread526 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= clOrdIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } - - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeSpread526 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeSpread526 & - putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeSpread526 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeSpread526 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 92; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpread526 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT { return 31; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastPxEncodingOffset() SBE_NOEXCEPT { - return 100; - } - - private: - PRICE9 m_lastPx; - - public: - SBE_NODISCARD PRICE9 &lastPx() { - m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); - return m_lastPx; - } - - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 108; - } - - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpread526 & - orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= priceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 116; - } - - private: - PRICE9 m_price; - - public: - SBE_NODISCARD PRICE9 &price() { - m_price.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); - return m_price; - } - - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= stopPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 124; - } - - private: - PRICENULL9 m_stopPx; - - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 124, m_actingVersion, m_bufferLength); - return m_stopPx; - } - - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= transactTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 132; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpread526 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 140; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpread526 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderRequestIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 148; - } - - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpread526 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT { return 527; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - secExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= secExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - secExecIDEncodingOffset() SBE_NOEXCEPT { - return 156; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpread526 & - secExecID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT { return 548; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= crossIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossIDEncodingOffset() SBE_NOEXCEPT { - return 164; - } - - static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 164, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpread526 & - crossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 164, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT { - return 961; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hostCrossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= hostCrossIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hostCrossIDEncodingOffset() SBE_NOEXCEPT { - return 172; - } - - static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 172, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpread526 & - hostCrossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 172, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 180; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 180; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 180; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 180 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeSpread526 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 180 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 180, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeSpread526 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 180, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 180; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 180; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeSpread526 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 180, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 180 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeSpread526 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 180, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 180 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 185; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpread526 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 189; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpread526 & - orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT { return 32; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastQtyEncodingOffset() SBE_NOEXCEPT { - return 193; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpread526 & - lastQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT { return 14; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cumQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= cumQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cumQtyEncodingOffset() SBE_NOEXCEPT { - return 197; - } - - static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpread526 & - cumQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 197, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDTradeEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDTradeEntryIDId() SBE_NOEXCEPT { - return 37711; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDTradeEntryIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDTradeEntryIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDTradeEntryIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingOffset() SBE_NOEXCEPT { - return 201; - } - - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t mDTradeEntryID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpread526 & - mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT { - return 1506; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideTradeIDEncodingOffset() SBE_NOEXCEPT { - return 205; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 205, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpread526 & - sideTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 205, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT { return 151; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - leavesQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= leavesQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - leavesQtyEncodingOffset() SBE_NOEXCEPT { - return 209; - } - - static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 209, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpread526 & - leavesQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 209, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT { return 75; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradeDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradeDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeDateEncodingOffset() SBE_NOEXCEPT { - return 213; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 213, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - ExecutionReportTradeSpread526 & - tradeDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 213, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= expireDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 215; - } - - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 215, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - ExecutionReportTradeSpread526 & - expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 215, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordStatusSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 217; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrdStatusTrd::Value ordStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 217, sizeof(std::uint8_t)); - return OrdStatusTrd::get((val)); - } - - ExecutionReportTradeSpread526 & - ordStatus(const OrdStatusTrd::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 217, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 218; - } - - static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *execType() const { - static const std::uint8_t execTypeValues[] = {70}; - - return (const char *)execTypeValues; - } - - SBE_NODISCARD char execType(const std::uint64_t index) const { - static const std::uint8_t execTypeValues[] = {70}; - - return (char)execTypeValues[index]; - } - - std::uint64_t getExecType(char *dst, const std::uint64_t length) const { - static std::uint8_t execTypeValues[] = {70}; - std::uint64_t bytesToCopy = - length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); - - std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getExecTypeAsString() const { - static const std::uint8_t ExecTypeValues[] = {70}; - - return std::string((const char *)ExecTypeValues, 1); - } - - std::string getExecTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecTypeAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 218; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 218, sizeof(char)); - return OrderType::get((val)); - } - - ExecutionReportTradeSpread526 & - ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 218, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 219; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 219, sizeof(std::uint8_t)); - return SideReq::get((val)); - } - - ExecutionReportTradeSpread526 & - side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 219, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= timeInForceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 220; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 220, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } - - ExecutionReportTradeSpread526 & - timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 220, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 221; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 221, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - ExecutionReportTradeSpread526 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 221, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= possRetransFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 222; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 222, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - ExecutionReportTradeSpread526 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 222, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *AggressorIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t aggressorIndicatorId() SBE_NOEXCEPT { - return 1057; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - aggressorIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool aggressorIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= aggressorIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - aggressorIndicatorEncodingOffset() SBE_NOEXCEPT { - return 223; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - aggressorIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value aggressorIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 223, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - ExecutionReportTradeSpread526 & - aggressorIndicator(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 223, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT { return 549; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= crossTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossTypeEncodingOffset() SBE_NOEXCEPT { - return 224; - } - - static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } - - static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 224, sizeof(std::uint8_t)); - return (val); - } - - ExecutionReportTradeSpread526 & - crossType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 224, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *TotalNumSecuritiesMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t totalNumSecuritiesId() SBE_NOEXCEPT { - return 393; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totalNumSecuritiesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool totalNumSecuritiesInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= totalNumSecuritiesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totalNumSecuritiesEncodingOffset() SBE_NOEXCEPT { - return 225; - } - - static SBE_CONSTEXPR std::uint8_t - totalNumSecuritiesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - totalNumSecuritiesEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t totalNumSecurities() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 225, sizeof(std::uint8_t)); - return (val); - } - - ExecutionReportTradeSpread526 & - totalNumSecurities(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 225, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execInstSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 226; - } - - private: - ExecInst m_execInst; - - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 226, m_actingVersion, m_bufferLength); - return m_execInst; - } - - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= executionModeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 227; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 227, sizeof(char)); - return ExecMode::get((val)); - } - - ExecutionReportTradeSpread526 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 227, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= liquidityFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 228; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 228, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - ExecutionReportTradeSpread526 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 228, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= shortSaleTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 229; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 229, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } - - ExecutionReportTradeSpread526 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 229, &val, sizeof(std::uint8_t)); - return *this; - } - - class NoFills { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)15); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 15; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 15; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { +class ExecutionReportTradeSpread526 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(230); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(526); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + ExecutionReportTradeSpread526() = default; + + ExecutionReportTradeSpread526( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + ExecutionReportTradeSpread526(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportTradeSpread526(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + ExecutionReportTradeSpread526( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportTradeSpread526(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(230); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(526); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + ExecutionReportTradeSpread526 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeSpread526(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + ExecutionReportTradeSpread526 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = ExecutionReportTradeSpread526( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + ExecutionReportTradeSpread526 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeSpread526(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + ExecutionReportTradeSpread526 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + } + return position; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportTradeSpread526 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoFills &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - return *this; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD static const char * - FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT { - return 1364; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillPxSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICE9 m_fillPx; + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - public: - SBE_NODISCARD PRICE9 &fillPx() { - m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_fillPx; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - SBE_NODISCARD static const char * - FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT { - return 1365; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT { + ExecutionReportTradeSpread526 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillQtySinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportTradeSpread526 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT { - return 1363; - } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillExecIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillExecIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char fillExecID(const std::uint64_t index) const { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy( - &val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - NoFills &fillExecID(const std::uint64_t index, const char value) { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E105]"); - } + ExecutionReportTradeSpread526 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy( - m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getFillExecID(char *const dst, const std::uint64_t length) const { - if (length > 2) { - throw std::runtime_error( - "length too large for getFillExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); - return *this; - } + ExecutionReportTradeSpread526 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - NoFills & - putFillExecID(const char value0, const char value1) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - return *this; - } + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - SBE_NODISCARD std::string getFillExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + return result; + } - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - return result; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - std::string getFillExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getFillExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getFillExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NoFills &putFillExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportTradeSpread526 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#else - NoFills &putFillExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + return *this; + } + #else + ExecutionReportTradeSpread526 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *FillYieldTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT { - return 1622; - } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillYieldTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillYieldTypeSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return (val); - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoFills writer) { - builder << '{'; - builder << R"("FillPx": )"; - builder << writer.fillPx(); + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - builder << ", "; - builder << R"("FillQty": )"; - builder << +writer.fillQty(); + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - builder << ", "; - builder << R"("FillExecID": )"; - builder << '"' << writer.getFillExecIDAsJsonEscapedString().c_str() - << '"'; + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - builder << ", "; - builder << R"("FillYieldType": )"; - builder << +writer.fillYieldType(); + ExecutionReportTradeSpread526 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - builder << '}'; + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - return builder; - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - void skip() {} + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + ExecutionReportTradeSpread526 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - private: - NoFills m_noFills; + return result; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT { - return 1362; - } + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - SBE_NODISCARD inline NoFills &noFills() { - m_noFills.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - NoFills &noFillsCount(const std::uint8_t count) { - m_noFills.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noFillsSinceVersion() SBE_NOEXCEPT { - return 0; - } + return oss.str(); + } - SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT { + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeSpread526 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeSpread526 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noFillsSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoLegs { + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } + + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeSpread526 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeSpread526 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeSpread526 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeSpread526 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 92; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpread526 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT + { + return 31; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastPxSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastPxEncodingOffset() SBE_NOEXCEPT + { + return 100; + } + +private: + PRICE9 m_lastPx; + +public: + SBE_NODISCARD PRICE9 &lastPx() + { + m_lastPx.wrap(m_buffer, m_offset + 100, m_actingVersion, m_bufferLength); + return m_lastPx; + } + + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 108; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpread526 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= priceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 116; + } + +private: + PRICE9 m_price; + +public: + SBE_NODISCARD PRICE9 &price() + { + m_price.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); + return m_price; + } + + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= stopPxSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 124; + } + +private: + PRICENULL9 m_stopPx; + +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 124, m_actingVersion, m_bufferLength); + return m_stopPx; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= transactTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 132; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpread526 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 140; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpread526 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderRequestIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 148; + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 148, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpread526 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 148, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT + { + return 527; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t secExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= secExecIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t secExecIDEncodingOffset() SBE_NOEXCEPT + { + return 156; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 156, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpread526 &secExecID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 156, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT + { + return 548; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= crossIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossIDEncodingOffset() SBE_NOEXCEPT + { + return 164; + } + + static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 164, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpread526 &crossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 164, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *HostCrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t hostCrossIDId() SBE_NOEXCEPT + { + return 961; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hostCrossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool hostCrossIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= hostCrossIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hostCrossIDEncodingOffset() SBE_NOEXCEPT + { + return 172; + } + + static SBE_CONSTEXPR std::uint64_t hostCrossIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t hostCrossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t hostCrossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t hostCrossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t hostCrossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 172, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpread526 &hostCrossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 172, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 180; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 180; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 180; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 180 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeSpread526 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 180 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 180, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeSpread526 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 180, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 180; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 180; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeSpread526 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 180, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 180 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeSpread526 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 180, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 180 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 185; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpread526 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 189; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpread526 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT + { + return 32; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastQtyEncodingOffset() SBE_NOEXCEPT + { + return 193; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpread526 &lastQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT + { + return 14; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cumQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cumQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cumQtyEncodingOffset() SBE_NOEXCEPT + { + return 197; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpread526 &cumQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 197, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *MDTradeEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDTradeEntryIDId() SBE_NOEXCEPT + { + return 37711; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDTradeEntryIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDTradeEntryIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= mDTradeEntryIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDTradeEntryIDEncodingOffset() SBE_NOEXCEPT + { + return 201; + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t mDTradeEntryIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t mDTradeEntryID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 201, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpread526 &mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 201, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT + { + return 1506; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideTradeIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 205; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 205, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpread526 &sideTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 205, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LeavesQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t leavesQtyId() SBE_NOEXCEPT + { + return 151; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t leavesQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool leavesQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= leavesQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t leavesQtyEncodingOffset() SBE_NOEXCEPT + { + return 209; + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t leavesQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t leavesQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t leavesQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 209, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpread526 &leavesQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 209, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT + { + return 75; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradeDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= tradeDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeDateEncodingOffset() SBE_NOEXCEPT + { + return 213; + } + + static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 213, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeSpread526 &tradeDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 213, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= expireDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 215; + } + + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 215, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeSpread526 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 215, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordStatusSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 217; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t ordStatusRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 217, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD OrdStatusTrd::Value ordStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 217, sizeof(std::uint8_t)); + return OrdStatusTrd::get((val)); + } + + ExecutionReportTradeSpread526 &ordStatus(const OrdStatusTrd::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 217, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 218; + } + + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 70, 0 }; + + return (const char *)execTypeValues; + } + + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 70, 0 }; + + return (char)execTypeValues[index]; + } + + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 70 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 70 }; + + return std::string((const char *)ExecTypeValues, 1); + } + + std::string getExecTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 218; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 218, sizeof(char)); + return (val); + } + + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 218, sizeof(char)); + return OrderType::get((val)); + } + + ExecutionReportTradeSpread526 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 218, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 219; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 219, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 219, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + ExecutionReportTradeSpread526 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 219, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= timeInForceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 220; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 220, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 220, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } + + ExecutionReportTradeSpread526 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 220, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= manualOrderIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 221; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 221, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 221, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } + + ExecutionReportTradeSpread526 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 221, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= possRetransFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 222; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 222, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 222, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportTradeSpread526 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 222, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *AggressorIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t aggressorIndicatorId() SBE_NOEXCEPT + { + return 1057; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t aggressorIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool aggressorIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= aggressorIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t aggressorIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 223; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t aggressorIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t aggressorIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 223, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value aggressorIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 223, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportTradeSpread526 &aggressorIndicator(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 223, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT + { + return 549; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= crossTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossTypeEncodingOffset() SBE_NOEXCEPT + { + return 224; + } + + static SBE_CONSTEXPR std::uint8_t crossTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t crossTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t crossTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t crossType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 224, sizeof(std::uint8_t)); + return (val); + } + + ExecutionReportTradeSpread526 &crossType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 224, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *TotalNumSecuritiesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t totalNumSecuritiesId() SBE_NOEXCEPT + { + return 393; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totalNumSecuritiesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool totalNumSecuritiesInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= totalNumSecuritiesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totalNumSecuritiesEncodingOffset() SBE_NOEXCEPT + { + return 225; + } + + static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t totalNumSecuritiesMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t totalNumSecuritiesEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t totalNumSecurities() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 225, sizeof(std::uint8_t)); + return (val); + } + + ExecutionReportTradeSpread526 &totalNumSecurities(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 225, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execInstSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 226; + } + +private: + ExecInst m_execInst; + +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 226, m_actingVersion, m_bufferLength); + return m_execInst; + } + + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= executionModeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 227; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 227, sizeof(char)); + return (val); + } + + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 227, sizeof(char)); + return ExecMode::get((val)); + } + + ExecutionReportTradeSpread526 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 227, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= liquidityFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 228; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 228, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 228, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + ExecutionReportTradeSpread526 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 228, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= shortSaleTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 229; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 229, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 229, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } + + ExecutionReportTradeSpread526 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 229, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoFills + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(15)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 15; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 15; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoFills &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT + { + return 1364; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_fillPx; + +public: + SBE_NODISCARD PRICE9 &fillPx() + { + m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_fillPx; + } + + SBE_NODISCARD static const char *FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT + { + return 1365; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillQtyEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT + { + return 1363; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillExecIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char fillExecID(const std::uint64_t index) const + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } + + NoFills &fillExecID(const std::uint64_t index, const char value) + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getFillExecID(char *const dst, const std::uint64_t length) const + { + if (length > 2) + { + throw std::runtime_error("length too large for getFillExecID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } + + NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); + return *this; + } + + NoFills &putFillExecID( + const char value0, + const char value1) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getFillExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getFillExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getFillExecIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getFillExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoFills &putFillExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #else + NoFills &putFillExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *FillYieldTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT + { + return 1622; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillYieldTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillYieldTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingOffset() SBE_NOEXCEPT + { + return 14; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return (val); + } + + NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoFills writer) + { + builder << '{'; + builder << R"("FillPx": )"; + builder << writer.fillPx(); + + builder << ", "; + builder << R"("FillQty": )"; + builder << +writer.fillQty(); + + builder << ", "; + builder << R"("FillExecID": )"; + builder << '"' << + writer.getFillExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("FillYieldType": )"; + builder << +writer.fillYieldType(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)29); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 29; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoFills m_noFills; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 29; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT + { + return 1362; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoFills &noFills() + { + m_noFills.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoFills &noFillsCount(const std::uint8_t count) + { + m_noFills.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noFillsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoLegs &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - LegExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legExecIDId() SBE_NOEXCEPT { - return 1893; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legExecIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legExecIDSinceVersion(); + return m_actingVersion >= noFillsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legExecIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t legExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t legExecIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t legExecIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t legExecIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t legExecID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoLegs &legExecID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LegLastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t legLastPxId() SBE_NOEXCEPT { - return 637; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legLastPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legLastPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legLastPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legLastPxEncodingOffset() SBE_NOEXCEPT { - return 8; - } + } + class NoLegs + { private: - PRICE9 m_legLastPx; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; + + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - SBE_NODISCARD PRICE9 &legLastPx() { - m_legLastPx.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_legLastPx; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - SBE_NODISCARD static const char *LegSecurityIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(29)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 29; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - static SBE_CONSTEXPR std::uint16_t legSecurityIDId() SBE_NOEXCEPT { - return 602; - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSecurityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 29; + } - SBE_NODISCARD bool legSecurityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legSecurityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSecurityIDEncodingOffset() SBE_NOEXCEPT { - return 16; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - static SBE_CONSTEXPR std::int32_t legSecurityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - static SBE_CONSTEXPR std::int32_t legSecurityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - static SBE_CONSTEXPR std::int32_t legSecurityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - static SBE_CONSTEXPR std::size_t - legSecurityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + inline NoLegs &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - SBE_NODISCARD std::int32_t legSecurityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + return *this; + } - NoLegs &legSecurityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::int32_t)); - return *this; - } + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } - SBE_NODISCARD static const char * - LegTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - static SBE_CONSTEXPR std::uint16_t legTradeIDId() SBE_NOEXCEPT { - return 1894; - } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static const char *LegExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD bool legTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + static SBE_CONSTEXPR std::uint16_t legExecIDId() SBE_NOEXCEPT + { + return 1893; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legTradeIDEncodingOffset() SBE_NOEXCEPT { - return 20; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t legTradeIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + SBE_NODISCARD bool legExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - static SBE_CONSTEXPR std::uint32_t legTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legExecIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t legTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint64_t legExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::size_t legTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint64_t legExecIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - SBE_NODISCARD std::uint32_t legTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + static SBE_CONSTEXPR std::uint64_t legExecIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - NoLegs &legTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint32_t)); - return *this; - } + static SBE_CONSTEXPR std::size_t legExecIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD static const char * - LegLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD std::uint64_t legExecID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - static SBE_CONSTEXPR std::uint16_t legLastQtyId() SBE_NOEXCEPT { - return 1418; - } + NoLegs &legExecID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legLastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static const char *LegLastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD bool legLastQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legLastQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + static SBE_CONSTEXPR std::uint16_t legLastPxId() SBE_NOEXCEPT + { + return 637; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legLastQtyEncodingOffset() SBE_NOEXCEPT { - return 24; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legLastPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t legLastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + SBE_NODISCARD bool legLastPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legLastPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - static SBE_CONSTEXPR std::uint32_t legLastQtyMinValue() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legLastPxEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint32_t legLastQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } +private: + PRICE9 m_legLastPx; - static SBE_CONSTEXPR std::size_t legLastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } +public: + SBE_NODISCARD PRICE9 &legLastPx() + { + m_legLastPx.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_legLastPx; + } - SBE_NODISCARD std::uint32_t legLastQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD static const char *LegSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - NoLegs &legLastQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); - return *this; - } + static SBE_CONSTEXPR std::uint16_t legSecurityIDId() SBE_NOEXCEPT + { + return 602; + } - SBE_NODISCARD static const char * - LegSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSecurityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT { - return 624; - } + SBE_NODISCARD bool legSecurityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSecurityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSideSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSecurityIDEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD bool legSideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legSideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + static SBE_CONSTEXPR std::int32_t legSecurityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingOffset() SBE_NOEXCEPT { - return 28; - } + static SBE_CONSTEXPR std::int32_t legSecurityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::int32_t legSecurityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - SBE_NODISCARD SideReq::Value legSide() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + static SBE_CONSTEXPR std::size_t legSecurityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - NoLegs &legSide(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD std::int32_t legSecurityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoLegs writer) { - builder << '{'; - builder << R"("LegExecID": )"; - builder << +writer.legExecID(); + NoLegs &legSecurityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::int32_t)); + return *this; + } - builder << ", "; - builder << R"("LegLastPx": )"; - builder << writer.legLastPx(); + SBE_NODISCARD static const char *LegTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("LegSecurityID": )"; - builder << +writer.legSecurityID(); + static SBE_CONSTEXPR std::uint16_t legTradeIDId() SBE_NOEXCEPT + { + return 1894; + } - builder << ", "; - builder << R"("LegTradeID": )"; - builder << +writer.legTradeID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("LegLastQty": )"; - builder << +writer.legLastQty(); + SBE_NODISCARD bool legTradeIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legTradeIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - builder << ", "; - builder << R"("LegSide": )"; - builder << '"' << writer.legSide() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 20; + } - builder << '}'; + static SBE_CONSTEXPR std::uint32_t legTradeIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - return builder; - } + static SBE_CONSTEXPR std::uint32_t legTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - void skip() {} + static SBE_CONSTEXPR std::uint32_t legTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + static SBE_CONSTEXPR std::size_t legTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + SBE_NODISCARD std::uint32_t legTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoLegs &legTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LegLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legLastQtyId() SBE_NOEXCEPT + { + return 1418; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legLastQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legLastQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legLastQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legLastQtyEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + static SBE_CONSTEXPR std::uint32_t legLastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t legLastQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t legLastQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t legLastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t legLastQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoLegs &legLastQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *LegSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT + { + return 624; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legSideInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSideSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t legSideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value legSide() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + NoLegs &legSide(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoLegs writer) + { + builder << '{'; + builder << R"("LegExecID": )"; + builder << +writer.legExecID(); + + builder << ", "; + builder << R"("LegLastPx": )"; + builder << writer.legLastPx(); + + builder << ", "; + builder << R"("LegSecurityID": )"; + builder << +writer.legSecurityID(); + + builder << ", "; + builder << R"("LegTradeID": )"; + builder << +writer.legTradeID(); + + builder << ", "; + builder << R"("LegLastQty": )"; + builder << +writer.legLastQty(); + + builder << ", "; + builder << R"("LegSide": )"; + builder << '"' << writer.legSide() << '"'; + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoLegs m_noLegs; +private: + NoLegs m_noLegs; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT { - return 555; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT + { + return 555; + } - SBE_NODISCARD inline NoLegs &noLegs() { - m_noLegs.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + SBE_NODISCARD inline NoLegs &noLegs() + { + m_noLegs.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLegs; + } - NoLegs &noLegsCount(const std::uint8_t count) { - m_noLegs.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + NoLegs &noLegsCount(const std::uint8_t count) + { + m_noLegs.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLegs; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLegsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLegsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noLegsSinceVersion(); + return m_actingVersion >= noLegsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoOrderEvents { + class NoOrderEvents + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(23)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 23; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 23; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoOrderEvents &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *OrderEventPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT + { + return 1799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_orderEventPx; + +public: + SBE_NODISCARD PRICE9 &orderEventPx() + { + m_orderEventPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_orderEventPx; + } + + SBE_NODISCARD static const char *OrderEventTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT + { + return 1802; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTextSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTextSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTextEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t orderEventTextEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } + + SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } + + SBE_NODISCARD char orderEventText(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); + return (val); + } + + NoOrderEvents &orderEventText(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrderEventText(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getOrderEventText [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 8, sizeof(char) * static_cast(length)); + return length; + } + + NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getOrderEventTextAsString() const + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrderEventTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrderEventTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrderEventTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoOrderEvents &putOrderEventText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } + + return *this; + } + #else + NoOrderEvents &putOrderEventText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT + { + return 1797; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingOffset() SBE_NOEXCEPT + { + return 13; + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT + { + return 1800; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventQtyEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT + { + return 1796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD OrderEventType::Value orderEventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return OrderEventType::get((val)); + } + + NoOrderEvents &orderEventType(const OrderEventType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT + { + return 1798; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventReasonEncodingOffset() SBE_NOEXCEPT + { + return 22; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t orderEventReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); + return (val); + } + + NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoOrderEvents writer) + { + builder << '{'; + builder << R"("OrderEventPx": )"; + builder << writer.orderEventPx(); + + builder << ", "; + builder << R"("OrderEventText": )"; + builder << '"' << + writer.getOrderEventTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("OrderEventExecID": )"; + builder << +writer.orderEventExecID(); + + builder << ", "; + builder << R"("OrderEventQty": )"; + builder << +writer.orderEventQty(); + + builder << ", "; + builder << R"("OrderEventType": )"; + builder << '"' << writer.orderEventType() << '"'; + + builder << ", "; + builder << R"("OrderEventReason": )"; + builder << +writer.orderEventReason(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)23); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 23; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoOrderEvents m_noOrderEvents; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 23; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderEventsId() SBE_NOEXCEPT + { + return 1795; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoOrderEvents &noOrderEvents() + { + m_noOrderEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoOrderEvents &noOrderEventsCount(const std::uint8_t count) + { + m_noOrderEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderEventsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoOrderEvents &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *OrderEventPxMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT { - return 1799; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderEventPxSinceVersion(); + return m_actingVersion >= noOrderEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICE9 m_orderEventPx; - - public: - SBE_NODISCARD PRICE9 &orderEventPx() { - m_orderEventPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_orderEventPx; - } - - SBE_NODISCARD static const char *OrderEventTextMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT { - return 1802; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTextSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTextSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTextEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - orderEventTextEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char orderEventText(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); - return (val); - } - - NoOrderEvents & - orderEventText(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getOrderEventText(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error( - "length too large for getOrderEventText [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 8, - sizeof(char) * static_cast(length)); - return length; - } - - NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getOrderEventTextAsString() const { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getOrderEventTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrderEventTextAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getOrderEventTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoOrderEvents &putOrderEventText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } - - return *this; - } -#else - NoOrderEvents &putOrderEventText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT { - return 1797; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingOffset() SBE_NOEXCEPT { - return 13; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT { - return 1800; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT { - return 1796; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrderEventType::Value orderEventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); - return OrderEventType::get((val)); - } - - NoOrderEvents & - orderEventType(const OrderEventType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderEventReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT { - return 1798; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingOffset() SBE_NOEXCEPT { - return 22; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); - return (val); - } - - NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderEvents writer) { - builder << '{'; - builder << R"("OrderEventPx": )"; - builder << writer.orderEventPx(); - - builder << ", "; - builder << R"("OrderEventText": )"; - builder << '"' << writer.getOrderEventTextAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("OrderEventExecID": )"; - builder << +writer.orderEventExecID(); - - builder << ", "; - builder << R"("OrderEventQty": )"; - builder << +writer.orderEventQty(); - - builder << ", "; - builder << R"("OrderEventType": )"; - builder << '"' << writer.orderEventType() << '"'; - - builder << ", "; - builder << R"("OrderEventReason": )"; - builder << +writer.orderEventReason(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportTradeSpread526 _writer) +{ + ExecutionReportTradeSpread526 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "ExecutionReportTradeSpread526", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("LastPx": )"; + builder << writer.lastPx(); + + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); + + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("SecExecID": )"; + builder << +writer.secExecID(); + + builder << ", "; + builder << R"("CrossID": )"; + builder << +writer.crossID(); + + builder << ", "; + builder << R"("HostCrossID": )"; + builder << +writer.hostCrossID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("LastQty": )"; + builder << +writer.lastQty(); + + builder << ", "; + builder << R"("CumQty": )"; + builder << +writer.cumQty(); + + builder << ", "; + builder << R"("MDTradeEntryID": )"; + builder << +writer.mDTradeEntryID(); + + builder << ", "; + builder << R"("SideTradeID": )"; + builder << +writer.sideTradeID(); + + builder << ", "; + builder << R"("LeavesQty": )"; + builder << +writer.leavesQty(); + + builder << ", "; + builder << R"("TradeDate": )"; + builder << +writer.tradeDate(); + + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); + + builder << ", "; + builder << R"("OrdStatus": )"; + builder << '"' << writer.ordStatus() << '"'; + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("AggressorIndicator": )"; + builder << '"' << writer.aggressorIndicator() << '"'; + + builder << ", "; + builder << R"("CrossType": )"; + builder << +writer.crossType(); + + builder << ", "; + builder << R"("TotalNumSecurities": )"; + builder << +writer.totalNumSecurities(); + + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoFills": [)"; + writer.noFills().forEach( + [&](NoFills &noFills) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noFills; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLegs": [)"; + writer.noLegs().forEach( + [&](NoLegs &noLegs) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noLegs; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderEvents": [)"; + writer.noOrderEvents().forEach( + [&](NoOrderEvents &noOrderEvents) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderEvents; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noFillsGroup { noFills() }; + while (noFillsGroup.hasNext()) + { + noFillsGroup.next().skip(); + } + auto &noLegsGroup { noLegs() }; + while (noLegsGroup.hasNext()) + { + noLegsGroup.next().skip(); + } + auto &noOrderEventsGroup { noOrderEvents() }; + while (noOrderEventsGroup.hasNext()) + { + noOrderEventsGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noFillsLength = 0, + std::size_t noLegsLength = 0, + std::size_t noOrderEventsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + length += NoFills::sbeHeaderSize(); + if (noFillsLength > 254LL) + { + throw std::runtime_error("noFillsLength outside of allowed range [E110]"); + } + length += noFillsLength *NoFills::sbeBlockLength(); + + length += NoLegs::sbeHeaderSize(); + if (noLegsLength > 254LL) + { + throw std::runtime_error("noLegsLength outside of allowed range [E110]"); + } + length += noLegsLength *NoLegs::sbeBlockLength(); + + length += NoOrderEvents::sbeHeaderSize(); + if (noOrderEventsLength > 254LL) + { + throw std::runtime_error("noOrderEventsLength outside of allowed range [E110]"); + } + length += noOrderEventsLength *NoOrderEvents::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; - - private: - NoOrderEvents m_noOrderEvents; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderEventsId() SBE_NOEXCEPT { - return 1795; - } - - SBE_NODISCARD inline NoOrderEvents &noOrderEvents() { - m_noOrderEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } - - NoOrderEvents &noOrderEventsCount(const std::uint8_t count) { - m_noOrderEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noOrderEventsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportTradeSpread526 _writer) { - ExecutionReportTradeSpread526 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportTradeSpread526", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); - - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("LastPx": )"; - builder << writer.lastPx(); - - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("Price": )"; - builder << writer.price(); - - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); - - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); - - builder << ", "; - builder << R"("SecExecID": )"; - builder << +writer.secExecID(); - - builder << ", "; - builder << R"("CrossID": )"; - builder << +writer.crossID(); - - builder << ", "; - builder << R"("HostCrossID": )"; - builder << +writer.hostCrossID(); - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); - - builder << ", "; - builder << R"("LastQty": )"; - builder << +writer.lastQty(); - - builder << ", "; - builder << R"("CumQty": )"; - builder << +writer.cumQty(); - - builder << ", "; - builder << R"("MDTradeEntryID": )"; - builder << +writer.mDTradeEntryID(); - - builder << ", "; - builder << R"("SideTradeID": )"; - builder << +writer.sideTradeID(); - - builder << ", "; - builder << R"("LeavesQty": )"; - builder << +writer.leavesQty(); - - builder << ", "; - builder << R"("TradeDate": )"; - builder << +writer.tradeDate(); - - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); - - builder << ", "; - builder << R"("OrdStatus": )"; - builder << '"' << writer.ordStatus() << '"'; - - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; - - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; - - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; - - builder << ", "; - builder << R"("AggressorIndicator": )"; - builder << '"' << writer.aggressorIndicator() << '"'; - - builder << ", "; - builder << R"("CrossType": )"; - builder << +writer.crossType(); - - builder << ", "; - builder << R"("TotalNumSecurities": )"; - builder << +writer.totalNumSecurities(); - - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); - - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; - - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; - - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoFills": [)"; - writer.noFills().forEach([&](NoFills &noFills) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noFills; - }); - builder << ']'; - } - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLegs": [)"; - writer.noLegs().forEach([&](NoLegs &noLegs) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noLegs; - }); - builder << ']'; - } - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderEvents": [)"; - writer.noOrderEvents().forEach([&](NoOrderEvents &noOrderEvents) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderEvents; - }); - builder << ']'; - } - - builder << '}'; - - return builder; - } - - void skip() { - noFills().forEach([](NoFills e) { e.skip(); }); - noLegs().forEach([](NoLegs e) { e.skip(); }); - noOrderEvents().forEach([](NoOrderEvents e) { e.skip(); }); - } - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoFillsLength = 0, - std::size_t NoLegsLength = 0, - std::size_t NoOrderEventsLength = 0) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - length += NoFills::sbeHeaderSize(); - if (NoFillsLength > 254) { - throw std::runtime_error( - "NoFillsLength outside of allowed range [E110]"); - } - length += NoFillsLength * NoFills::sbeBlockLength(); - - length += NoLegs::sbeHeaderSize(); - if (NoLegsLength > 254) { - throw std::runtime_error( - "NoLegsLength outside of allowed range [E110]"); - } - length += NoLegsLength * NoLegs::sbeBlockLength(); - - length += NoOrderEvents::sbeHeaderSize(); - if (NoOrderEventsLength > 254) { - throw std::runtime_error( - "NoOrderEventsLength outside of allowed range [E110]"); - } - length += NoOrderEventsLength * NoOrderEvents::sbeBlockLength(); - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExecutionReportTradeSpreadLeg527.h b/src/lib/orderman/ilink3/generated/ExecutionReportTradeSpreadLeg527.h index 4d509dcdb..d7c1ede74 100644 --- a/src/lib/orderman/ilink3/generated/ExecutionReportTradeSpreadLeg527.h +++ b/src/lib/orderman/ilink3/generated/ExecutionReportTradeSpreadLeg527.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3928 +86,4415 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class ExecutionReportTradeSpreadLeg527 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - ExecutionReportTradeSpreadLeg527() = default; - - ExecutionReportTradeSpreadLeg527( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - ExecutionReportTradeSpreadLeg527( - char *buffer, const std::uint64_t bufferLength) - : ExecutionReportTradeSpreadLeg527( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - ExecutionReportTradeSpreadLeg527( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ExecutionReportTradeSpreadLeg527( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)199; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)527; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "8"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - ExecutionReportTradeSpreadLeg527 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeSpreadLeg527( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - ExecutionReportTradeSpreadLeg527 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = ExecutionReportTradeSpreadLeg527( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - ExecutionReportTradeSpreadLeg527 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = ExecutionReportTradeSpreadLeg527( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD std::uint64_t decodeLength() const { - ExecutionReportTradeSpreadLeg527 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpreadLeg527 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= uUIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpreadLeg527 & - uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } - - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } - - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeSpreadLeg527 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeSpreadLeg527 & - putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); - return *this; - } - - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeSpreadLeg527 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeSpreadLeg527 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 52; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeSpreadLeg527 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 52, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeSpreadLeg527 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 52; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeSpreadLeg527 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeSpreadLeg527 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 52 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= clOrdIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 72; - } - - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeSpreadLeg527 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeSpreadLeg527 & - putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeSpreadLeg527 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeSpreadLeg527 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - VolatilityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t volatilityId() SBE_NOEXCEPT { - return 1188; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - volatilitySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool volatilityInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= volatilitySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - volatilityEncodingOffset() SBE_NOEXCEPT { - return 92; - } - - private: - Decimal64NULL m_volatility; - - public: - SBE_NODISCARD Decimal64NULL &volatility() { - m_volatility.wrap( - m_buffer, m_offset + 92, m_actingVersion, m_bufferLength); - return m_volatility; - } - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 101; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 101, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpreadLeg527 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 101, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT { return 31; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastPxEncodingOffset() SBE_NOEXCEPT { - return 109; - } - - private: - PRICE9 m_lastPx; - - public: - SBE_NODISCARD PRICE9 &lastPx() { - m_lastPx.wrap(m_buffer, m_offset + 109, m_actingVersion, m_bufferLength); - return m_lastPx; - } - - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 117; - } - - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 117, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpreadLeg527 & - orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 117, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - UnderlyingPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t underlyingPxId() SBE_NOEXCEPT { - return 810; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool underlyingPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= underlyingPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingPxEncodingOffset() SBE_NOEXCEPT { - return 125; - } - - private: - PRICENULL9 m_underlyingPx; - - public: - SBE_NODISCARD PRICENULL9 &underlyingPx() { - m_underlyingPx.wrap( - m_buffer, m_offset + 125, m_actingVersion, m_bufferLength); - return m_underlyingPx; - } - - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= transactTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 133; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 133, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpreadLeg527 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 133, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 141; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 141, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpreadLeg527 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 141, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT { return 527; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - secExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= secExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - secExecIDEncodingOffset() SBE_NOEXCEPT { - return 149; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 149, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - ExecutionReportTradeSpreadLeg527 & - secExecID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 149, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 157; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 157; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 157; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 157 + (index * 1), sizeof(char)); - return (val); - } - - ExecutionReportTradeSpreadLeg527 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 157 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 157, - sizeof(char) * static_cast(length)); - return length; - } - - ExecutionReportTradeSpreadLeg527 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 157, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 157; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 157; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - ExecutionReportTradeSpreadLeg527 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 157, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 157 + start] = 0; - } - - return *this; - } -#else - ExecutionReportTradeSpreadLeg527 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 157, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 157 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - OptionDeltaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t optionDeltaId() SBE_NOEXCEPT { - return 811; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - optionDeltaSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool optionDeltaInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= optionDeltaSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - optionDeltaEncodingOffset() SBE_NOEXCEPT { - return 162; - } - - private: - Decimal32NULL m_optionDelta; - - public: - SBE_NODISCARD Decimal32NULL &optionDelta() { - m_optionDelta.wrap( - m_buffer, m_offset + 162, m_actingVersion, m_bufferLength); - return m_optionDelta; - } - - SBE_NODISCARD static const char *TimeToExpirationMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t timeToExpirationId() SBE_NOEXCEPT { - return 1189; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeToExpirationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool timeToExpirationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= timeToExpirationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeToExpirationEncodingOffset() SBE_NOEXCEPT { - return 167; - } - - private: - Decimal32NULL m_timeToExpiration; - - public: - SBE_NODISCARD Decimal32NULL &timeToExpiration() { - m_timeToExpiration.wrap( - m_buffer, m_offset + 167, m_actingVersion, m_bufferLength); - return m_timeToExpiration; - } - - SBE_NODISCARD static const char * - RiskFreeRateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t riskFreeRateId() SBE_NOEXCEPT { - return 1190; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - riskFreeRateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool riskFreeRateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= riskFreeRateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - riskFreeRateEncodingOffset() SBE_NOEXCEPT { - return 172; - } - - private: - Decimal32NULL m_riskFreeRate; - - public: - SBE_NODISCARD Decimal32NULL &riskFreeRate() { - m_riskFreeRate.wrap( - m_buffer, m_offset + 172, m_actingVersion, m_bufferLength); - return m_riskFreeRate; - } - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 177; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpreadLeg527 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT { return 32; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastQtyEncodingOffset() SBE_NOEXCEPT { - return 181; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpreadLeg527 & - lastQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT { return 14; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cumQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= cumQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cumQtyEncodingOffset() SBE_NOEXCEPT { - return 185; - } - - static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpreadLeg527 & - cumQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT { - return 1506; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideTradeIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideTradeIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideTradeIDEncodingOffset() SBE_NOEXCEPT { - return 189; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - ExecutionReportTradeSpreadLeg527 & - sideTradeID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT { return 75; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradeDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradeDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeDateEncodingOffset() SBE_NOEXCEPT { - return 193; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - ExecutionReportTradeSpreadLeg527 & - tradeDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordStatusSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 195; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrdStatusTrd::Value ordStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); - return OrdStatusTrd::get((val)); - } - - ExecutionReportTradeSpreadLeg527 & - ordStatus(const OrdStatusTrd::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT { return 150; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= execTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execTypeEncodingOffset() SBE_NOEXCEPT { - return 196; - } - - static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *execType() const { - static const std::uint8_t execTypeValues[] = {70}; - - return (const char *)execTypeValues; - } - - SBE_NODISCARD char execType(const std::uint64_t index) const { - static const std::uint8_t execTypeValues[] = {70}; - - return (char)execTypeValues[index]; - } - - std::uint64_t getExecType(char *dst, const std::uint64_t length) const { - static std::uint8_t execTypeValues[] = {70}; - std::uint64_t bytesToCopy = - length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); - - std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getExecTypeAsString() const { - static const std::uint8_t ExecTypeValues[] = {70}; - - return std::string((const char *)ExecTypeValues, 1); - } - - std::string getExecTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecTypeAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 196; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrderType::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 196, sizeof(char)); - return OrderType::get((val)); - } - - ExecutionReportTradeSpreadLeg527 & - ordType(const OrderType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 196, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 197; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint8_t)); - return SideReq::get((val)); - } - - ExecutionReportTradeSpreadLeg527 & - side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 197, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= possRetransFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 198; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - ExecutionReportTradeSpreadLeg527 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 198, &val, sizeof(std::uint8_t)); - return *this; - } - - class NoFills { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)15); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 15; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 15; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { +class ExecutionReportTradeSpreadLeg527 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(219); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(527); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + ExecutionReportTradeSpreadLeg527() = default; + + ExecutionReportTradeSpreadLeg527( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + ExecutionReportTradeSpreadLeg527(char *buffer, const std::uint64_t bufferLength) : + ExecutionReportTradeSpreadLeg527(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + ExecutionReportTradeSpreadLeg527( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ExecutionReportTradeSpreadLeg527(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(219); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(527); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "8"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + ExecutionReportTradeSpreadLeg527 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeSpreadLeg527(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + ExecutionReportTradeSpreadLeg527 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = ExecutionReportTradeSpreadLeg527( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + ExecutionReportTradeSpreadLeg527 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = ExecutionReportTradeSpreadLeg527(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + ExecutionReportTradeSpreadLeg527 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + } + return position; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ExecutionReportTradeSpreadLeg527 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoFills &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - return *this; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD static const char * - FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT { - return 1364; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillPxSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICE9 m_fillPx; + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - public: - SBE_NODISCARD PRICE9 &fillPx() { - m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_fillPx; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - SBE_NODISCARD static const char * - FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT { - return 1365; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT { + ExecutionReportTradeSpreadLeg527 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillQtySinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + ExecutionReportTradeSpreadLeg527 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT { - return 1363; - } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillExecIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillExecIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char fillExecID(const std::uint64_t index) const { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy( - &val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - NoFills &fillExecID(const std::uint64_t index, const char value) { - if (index >= 2) { - throw std::runtime_error( - "index out of range for fillExecID [E105]"); - } + ExecutionReportTradeSpreadLeg527 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy( - m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getFillExecID(char *const dst, const std::uint64_t length) const { - if (length > 2) { - throw std::runtime_error( - "length too large for getFillExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); - return *this; - } + ExecutionReportTradeSpreadLeg527 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 40); + return *this; + } - NoFills & - putFillExecID(const char value0, const char value1) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - return *this; - } + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - SBE_NODISCARD std::string getFillExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + return result; + } - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - return result; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - std::string getFillExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getFillExecIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getFillExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 2 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NoFills &putFillExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + #if __cplusplus >= 201703L + ExecutionReportTradeSpreadLeg527 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#else - NoFills &putFillExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 2) { - throw std::runtime_error( - "string too large for putFillExecID [E106]"); - } + return *this; + } + #else + ExecutionReportTradeSpreadLeg527 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 2; ++start) { + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { m_buffer[m_offset + 12 + start] = 0; - } + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *FillYieldTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT { - return 1622; - } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fillYieldTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fillYieldTypeSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - fillYieldTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return (val); - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoFills writer) { - builder << '{'; - builder << R"("FillPx": )"; - builder << writer.fillPx(); + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 52; + } - builder << ", "; - builder << R"("FillQty": )"; - builder << +writer.fillQty(); + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - builder << ", "; - builder << R"("FillExecID": )"; - builder << '"' << writer.getFillExecIDAsJsonEscapedString().c_str() - << '"'; + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } - builder << ", "; - builder << R"("FillYieldType": )"; - builder << +writer.fillYieldType(); + ExecutionReportTradeSpreadLeg527 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - builder << '}'; + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } - return builder; - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - void skip() {} + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + ExecutionReportTradeSpreadLeg527 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - private: - NoFills m_noFills; + return result; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT { - return 1362; - } + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - SBE_NODISCARD inline NoFills &noFills() { - m_noFills.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - NoFills &noFillsCount(const std::uint8_t count) { - m_noFills.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noFills; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noFillsSinceVersion() SBE_NOEXCEPT { - return 0; - } + return oss.str(); + } - SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT { + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeSpreadLeg527 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeSpreadLeg527 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noFillsSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoOrderEvents { + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 72; + } + + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } + + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeSpreadLeg527 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeSpreadLeg527 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeSpreadLeg527 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeSpreadLeg527 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *VolatilityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "float"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t volatilityId() SBE_NOEXCEPT + { + return 1188; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t volatilitySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool volatilityInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= volatilitySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t volatilityEncodingOffset() SBE_NOEXCEPT + { + return 92; + } + +private: + Decimal64NULL m_volatility; + +public: + SBE_NODISCARD Decimal64NULL &volatility() + { + m_volatility.wrap(m_buffer, m_offset + 92, m_actingVersion, m_bufferLength); + return m_volatility; + } + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 101; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 101, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpreadLeg527 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 101, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LastPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastPxId() SBE_NOEXCEPT + { + return 31; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastPxInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastPxSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastPxEncodingOffset() SBE_NOEXCEPT + { + return 109; + } + +private: + PRICE9 m_lastPx; + +public: + SBE_NODISCARD PRICE9 &lastPx() + { + m_lastPx.wrap(m_buffer, m_offset + 109, m_actingVersion, m_bufferLength); + return m_lastPx; + } + + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= orderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 117; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 117, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpreadLeg527 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 117, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *UnderlyingPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t underlyingPxId() SBE_NOEXCEPT + { + return 810; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool underlyingPxInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= underlyingPxSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingPxEncodingOffset() SBE_NOEXCEPT + { + return 125; + } + +private: + PRICENULL9 m_underlyingPx; + +public: + SBE_NODISCARD PRICENULL9 &underlyingPx() + { + m_underlyingPx.wrap(m_buffer, m_offset + 125, m_actingVersion, m_bufferLength); + return m_underlyingPx; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= transactTimeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 133; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 133, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpreadLeg527 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 133, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 141; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 141, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpreadLeg527 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 141, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t secExecIDId() SBE_NOEXCEPT + { + return 527; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t secExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool secExecIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= secExecIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t secExecIDEncodingOffset() SBE_NOEXCEPT + { + return 149; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t secExecIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t secExecIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t secExecID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 149, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + ExecutionReportTradeSpreadLeg527 &secExecID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 149, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 157; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 157; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 157; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 157 + (index * 1), sizeof(char)); + return (val); + } + + ExecutionReportTradeSpreadLeg527 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 157 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 157, sizeof(char) * static_cast(length)); + return length; + } + + ExecutionReportTradeSpreadLeg527 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 157, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 157; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 157; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + ExecutionReportTradeSpreadLeg527 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 157, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 157 + start] = 0; + } + + return *this; + } + #else + ExecutionReportTradeSpreadLeg527 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 157, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 157 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *OptionDeltaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "float"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t optionDeltaId() SBE_NOEXCEPT + { + return 811; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t optionDeltaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool optionDeltaInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= optionDeltaSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t optionDeltaEncodingOffset() SBE_NOEXCEPT + { + return 162; + } + +private: + Decimal32NULL m_optionDelta; + +public: + SBE_NODISCARD Decimal32NULL &optionDelta() + { + m_optionDelta.wrap(m_buffer, m_offset + 162, m_actingVersion, m_bufferLength); + return m_optionDelta; + } + + SBE_NODISCARD static const char *TimeToExpirationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "float"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t timeToExpirationId() SBE_NOEXCEPT + { + return 1189; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeToExpirationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeToExpirationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= timeToExpirationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeToExpirationEncodingOffset() SBE_NOEXCEPT + { + return 167; + } + +private: + Decimal32NULL m_timeToExpiration; + +public: + SBE_NODISCARD Decimal32NULL &timeToExpiration() + { + m_timeToExpiration.wrap(m_buffer, m_offset + 167, m_actingVersion, m_bufferLength); + return m_timeToExpiration; + } + + SBE_NODISCARD static const char *RiskFreeRateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "float"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t riskFreeRateId() SBE_NOEXCEPT + { + return 1190; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t riskFreeRateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool riskFreeRateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= riskFreeRateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t riskFreeRateEncodingOffset() SBE_NOEXCEPT + { + return 172; + } + +private: + Decimal32NULL m_riskFreeRate; + +public: + SBE_NODISCARD Decimal32NULL &riskFreeRate() + { + m_riskFreeRate.wrap(m_buffer, m_offset + 172, m_actingVersion, m_bufferLength); + return m_riskFreeRate; + } + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 177; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 177, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpreadLeg527 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 177, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastQtyId() SBE_NOEXCEPT + { + return 32; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= lastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastQtyEncodingOffset() SBE_NOEXCEPT + { + return 181; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t lastQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t lastQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 181, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpreadLeg527 &lastQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 181, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *CumQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cumQtyId() SBE_NOEXCEPT + { + return 14; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cumQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool cumQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cumQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cumQtyEncodingOffset() SBE_NOEXCEPT + { + return 185; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t cumQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t cumQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t cumQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 185, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpreadLeg527 &cumQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 185, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SideTradeIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideTradeIDId() SBE_NOEXCEPT + { + return 1506; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideTradeIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideTradeIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideTradeIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideTradeIDEncodingOffset() SBE_NOEXCEPT + { + return 189; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t sideTradeIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t sideTradeIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t sideTradeID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + ExecutionReportTradeSpreadLeg527 &sideTradeID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *TradeDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t tradeDateId() SBE_NOEXCEPT + { + return 75; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradeDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= tradeDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeDateEncodingOffset() SBE_NOEXCEPT + { + return 193; + } + + static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeSpreadLeg527 &tradeDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 193, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordStatusSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 195; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t ordStatusRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD OrdStatusTrd::Value ordStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::uint8_t)); + return OrdStatusTrd::get((val)); + } + + ExecutionReportTradeSpreadLeg527 &ordStatus(const OrdStatusTrd::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ExecTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t execTypeId() SBE_NOEXCEPT + { + return 150; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= execTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execTypeEncodingOffset() SBE_NOEXCEPT + { + return 196; + } + + static SBE_CONSTEXPR char execTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char execTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char execTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t execTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t execTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *execType() const + { + static const std::uint8_t execTypeValues[] = { 70, 0 }; + + return (const char *)execTypeValues; + } + + SBE_NODISCARD char execType(const std::uint64_t index) const + { + static const std::uint8_t execTypeValues[] = { 70, 0 }; + + return (char)execTypeValues[index]; + } + + std::uint64_t getExecType(char *dst, const std::uint64_t length) const + { + static std::uint8_t execTypeValues[] = { 70 }; + std::uint64_t bytesToCopy = length < sizeof(execTypeValues) ? length : sizeof(execTypeValues); + + std::memcpy(dst, execTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getExecTypeAsString() const + { + static const std::uint8_t ExecTypeValues[] = { 70 }; + + return std::string((const char *)ExecTypeValues, 1); + } + + std::string getExecTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= ordTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 196; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 196, sizeof(char)); + return (val); + } + + SBE_NODISCARD OrderType::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 196, sizeof(char)); + return OrderType::get((val)); + } + + ExecutionReportTradeSpreadLeg527 &ordType(const OrderType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 196, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sideSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 197; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 197, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + ExecutionReportTradeSpreadLeg527 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 197, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= possRetransFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 198; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 198, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + ExecutionReportTradeSpreadLeg527 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 198, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SettlDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t settlDateId() SBE_NOEXCEPT + { + return 64; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlDateSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool settlDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= settlDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlDateEncodingOffset() SBE_NOEXCEPT + { + return 199; + } + + static SBE_CONSTEXPR std::uint16_t settlDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t settlDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t settlDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t settlDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t settlDate() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } + + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + ExecutionReportTradeSpreadLeg527 &settlDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *CalculatedCcyLastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t calculatedCcyLastQtyId() SBE_NOEXCEPT + { + return 1056; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t calculatedCcyLastQtySinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool calculatedCcyLastQtyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= calculatedCcyLastQtySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t calculatedCcyLastQtyEncodingOffset() SBE_NOEXCEPT + { + return 201; + } + +private: + Decimal64NULL m_calculatedCcyLastQty; + +public: + SBE_NODISCARD Decimal64NULL &calculatedCcyLastQty() + { + m_calculatedCcyLastQty.wrap(m_buffer, m_offset + 201, m_actingVersion, m_bufferLength); + return m_calculatedCcyLastQty; + } + + SBE_NODISCARD static const char *GrossTradeAmtMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t grossTradeAmtId() SBE_NOEXCEPT + { + return 381; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t grossTradeAmtSinceVersion() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD bool grossTradeAmtInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= grossTradeAmtSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t grossTradeAmtEncodingOffset() SBE_NOEXCEPT + { + return 210; + } + +private: + Decimal64NULL m_grossTradeAmt; + +public: + SBE_NODISCARD Decimal64NULL &grossTradeAmt() + { + m_grossTradeAmt.wrap(m_buffer, m_offset + 210, m_actingVersion, m_bufferLength); + return m_grossTradeAmt; + } + + class NoFills + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(15)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 15; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 15; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoFills &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *FillPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillPxId() SBE_NOEXCEPT + { + return 1364; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_fillPx; + +public: + SBE_NODISCARD PRICE9 &fillPx() + { + m_fillPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_fillPx; + } + + SBE_NODISCARD static const char *FillQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillQtyId() SBE_NOEXCEPT + { + return 1365; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillQtyEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t fillQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t fillQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t fillQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoFills &fillQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *FillExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillExecIDId() SBE_NOEXCEPT + { + return 1363; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillExecIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR char fillExecIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char fillExecIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char fillExecIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t fillExecIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + static SBE_CONSTEXPR std::uint64_t fillExecIDLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD const char *fillExecID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char *fillExecID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } + + SBE_NODISCARD char fillExecID(const std::uint64_t index) const + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } + + NoFills &fillExecID(const std::uint64_t index, const char value) + { + if (index >= 2) + { + throw std::runtime_error("index out of range for fillExecID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getFillExecID(char *const dst, const std::uint64_t length) const + { + if (length > 2) + { + throw std::runtime_error("length too large for getFillExecID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } + + NoFills &putFillExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 2); + return *this; + } + + NoFills &putFillExecID( + const char value0, + const char value1) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 12, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 13, &val1, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getFillExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getFillExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getFillExecIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getFillExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; + + for (; length < 2 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoFills &putFillExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #else + NoFills &putFillExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 2) + { + throw std::runtime_error("string too large for putFillExecID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 2; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *FillYieldTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t fillYieldTypeId() SBE_NOEXCEPT + { + return 1622; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fillYieldTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool fillYieldTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= fillYieldTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingOffset() SBE_NOEXCEPT + { + return 14; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t fillYieldTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t fillYieldTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t fillYieldType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return (val); + } + + NoFills &fillYieldType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoFills writer) + { + builder << '{'; + builder << R"("FillPx": )"; + builder << writer.fillPx(); + + builder << ", "; + builder << R"("FillQty": )"; + builder << +writer.fillQty(); + + builder << ", "; + builder << R"("FillExecID": )"; + builder << '"' << + writer.getFillExecIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("FillYieldType": )"; + builder << +writer.fillYieldType(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)23); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 23; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoFills m_noFills; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 23; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoFillsId() SBE_NOEXCEPT + { + return 1362; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoFills &noFills() + { + m_noFills.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoFills &noFillsCount(const std::uint8_t count) + { + m_noFills.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noFills; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noFillsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoOrderEvents &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *OrderEventPxMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT { - return 1799; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noFillsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderEventPxSinceVersion(); + return m_actingVersion >= noFillsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoOrderEvents + { private: - PRICE9 m_orderEventPx; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; + + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - SBE_NODISCARD PRICE9 &orderEventPx() { - m_orderEventPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_orderEventPx; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - SBE_NODISCARD static const char *OrderEventTextMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT { - return 1802; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTextSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTextSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTextEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - orderEventTextEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } - - SBE_NODISCARD char orderEventText(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); - return (val); - } - - NoOrderEvents & - orderEventText(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error( - "index out of range for orderEventText [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getOrderEventText(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error( - "length too large for getOrderEventText [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 8, - sizeof(char) * static_cast(length)); - return length; - } - - NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getOrderEventTextAsString() const { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getOrderEventTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrderEventTextAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(23)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 23; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - return oss.str(); - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getOrderEventTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 23; + } - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - return result; - } -#endif + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } -#if __cplusplus >= 201703L - NoOrderEvents &putOrderEventText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - return *this; - } -#else - NoOrderEvents &putOrderEventText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putOrderEventText [E106]"); - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } + inline NoOrderEvents &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - return *this; - } -#endif + return *this; + } - SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } - static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT { - return 1797; - } + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventExecIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventExecIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD static const char *OrderEventPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingOffset() SBE_NOEXCEPT { - return 13; - } + static SBE_CONSTEXPR std::uint16_t orderEventPxId() SBE_NOEXCEPT + { + return 1799; + } - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMinValue() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD bool orderEventPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - static SBE_CONSTEXPR std::uint32_t - orderEventExecIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::size_t - orderEventExecIDEncodingLength() SBE_NOEXCEPT { - return 4; - } +private: + PRICE9 m_orderEventPx; - SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } +public: + SBE_NODISCARD PRICE9 &orderEventPx() + { + m_orderEventPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_orderEventPx; + } - NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); - return *this; - } + SBE_NODISCARD static const char *OrderEventTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static const char *OrderEventQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint16_t orderEventTextId() SBE_NOEXCEPT + { + return 1802; + } - static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT { - return 1800; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTextSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD bool orderEventTextInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTextSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTextEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingOffset() SBE_NOEXCEPT { - return 17; - } + static SBE_CONSTEXPR char orderEventTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR char orderEventTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR char orderEventTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::size_t orderEventTextEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::size_t - orderEventQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint64_t orderEventTextLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD const char *orderEventText() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } - NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + SBE_NODISCARD char *orderEventText() SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } - SBE_NODISCARD static const char *OrderEventTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char orderEventText(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E104]"); + } - static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT { - return 1796; - } + char val; + std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); + return (val); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + NoOrderEvents &orderEventText(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for orderEventText [E105]"); + } - SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + char val = (value); + std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingOffset() SBE_NOEXCEPT { - return 21; - } + std::uint64_t getOrderEventText(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getOrderEventText [E106]"); + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + std::memcpy(dst, m_buffer + m_offset + 8, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD OrderEventType::Value orderEventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); - return OrderEventType::get((val)); - } + NoOrderEvents &putOrderEventText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 5); + return *this; + } - NoOrderEvents & - orderEventType(const OrderEventType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD std::string getOrderEventTextAsString() const + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; - SBE_NODISCARD static const char *OrderEventReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT { - return 1798; - } + return result; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderEventReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + std::string getOrderEventTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrderEventTextAsString(); - SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderEventReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingOffset() SBE_NOEXCEPT { - return 22; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - static SBE_CONSTEXPR std::uint8_t - orderEventReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + return oss.str(); + } - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrderEventTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 8; + std::size_t length = 0; - static SBE_CONSTEXPR std::uint8_t - orderEventReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - static SBE_CONSTEXPR std::size_t - orderEventReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } + return result; + } + #endif - SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); - return (val); - } + #if __cplusplus >= 201703L + NoOrderEvents &putOrderEventText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } - NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); - return *this; - } + std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderEvents writer) { - builder << '{'; - builder << R"("OrderEventPx": )"; - builder << writer.orderEventPx(); + return *this; + } + #else + NoOrderEvents &putOrderEventText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putOrderEventText [E106]"); + } - builder << ", "; - builder << R"("OrderEventText": )"; - builder << '"' << writer.getOrderEventTextAsJsonEscapedString().c_str() - << '"'; + std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } - builder << ", "; - builder << R"("OrderEventExecID": )"; - builder << +writer.orderEventExecID(); + return *this; + } + #endif - builder << ", "; - builder << R"("OrderEventQty": )"; - builder << +writer.orderEventQty(); + SBE_NODISCARD static const char *OrderEventExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("OrderEventType": )"; - builder << '"' << writer.orderEventType() << '"'; + static SBE_CONSTEXPR std::uint16_t orderEventExecIDId() SBE_NOEXCEPT + { + return 1797; + } - builder << ", "; - builder << R"("OrderEventReason": )"; - builder << +writer.orderEventReason(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventExecIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - builder << '}'; + SBE_NODISCARD bool orderEventExecIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventExecIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - return builder; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingOffset() SBE_NOEXCEPT + { + return 13; + } - void skip() {} + static SBE_CONSTEXPR std::uint32_t orderEventExecIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + static SBE_CONSTEXPR std::uint32_t orderEventExecIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventExecIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventExecID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventExecID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventQtyId() SBE_NOEXCEPT + { + return 1800; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventQtyEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderEventQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderEventQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderEventQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoOrderEvents &orderEventQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventTypeId() SBE_NOEXCEPT + { + return 1796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD OrderEventType::Value orderEventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return OrderEventType::get((val)); + } + + NoOrderEvents &orderEventType(const OrderEventType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderEventReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderEventReasonId() SBE_NOEXCEPT + { + return 1798; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderEventReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderEventReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderEventReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderEventReasonEncodingOffset() SBE_NOEXCEPT + { + return 22; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t orderEventReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t orderEventReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t orderEventReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 22, sizeof(std::uint8_t)); + return (val); + } + + NoOrderEvents &orderEventReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 22, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoOrderEvents writer) + { + builder << '{'; + builder << R"("OrderEventPx": )"; + builder << writer.orderEventPx(); + + builder << ", "; + builder << R"("OrderEventText": )"; + builder << '"' << + writer.getOrderEventTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("OrderEventExecID": )"; + builder << +writer.orderEventExecID(); + + builder << ", "; + builder << R"("OrderEventQty": )"; + builder << +writer.orderEventQty(); + + builder << ", "; + builder << R"("OrderEventType": )"; + builder << '"' << writer.orderEventType() << '"'; + + builder << ", "; + builder << R"("OrderEventReason": )"; + builder << +writer.orderEventReason(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoOrderEvents m_noOrderEvents; +private: + NoOrderEvents m_noOrderEvents; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderEventsId() SBE_NOEXCEPT { - return 1795; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderEventsId() SBE_NOEXCEPT + { + return 1795; + } - SBE_NODISCARD inline NoOrderEvents &noOrderEvents() { - m_noOrderEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } + SBE_NODISCARD inline NoOrderEvents &noOrderEvents() + { + m_noOrderEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - NoOrderEvents &noOrderEventsCount(const std::uint8_t count) { - m_noOrderEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderEvents; - } + NoOrderEvents &noOrderEventsCount(const std::uint8_t count) + { + m_noOrderEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderEvents; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderEventsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noOrderEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noOrderEventsSinceVersion(); + return m_actingVersion >= noOrderEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - ExecutionReportTradeSpreadLeg527 _writer) { - ExecutionReportTradeSpreadLeg527 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ExecutionReportTradeSpreadLeg527", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, ExecutionReportTradeSpreadLeg527 _writer) +{ + ExecutionReportTradeSpreadLeg527 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << '{'; + builder << R"("Name": "ExecutionReportTradeSpreadLeg527", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("Volatility": )"; - builder << writer.volatility(); + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << ", "; + builder << R"("Volatility": )"; + builder << writer.volatility(); - builder << ", "; - builder << R"("LastPx": )"; - builder << writer.lastPx(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + builder << ", "; + builder << R"("LastPx": )"; + builder << writer.lastPx(); - builder << ", "; - builder << R"("UnderlyingPx": )"; - builder << writer.underlyingPx(); + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + builder << ", "; + builder << R"("UnderlyingPx": )"; + builder << writer.underlyingPx(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("SecExecID": )"; - builder << +writer.secExecID(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SecExecID": )"; + builder << +writer.secExecID(); - builder << ", "; - builder << R"("OptionDelta": )"; - builder << writer.optionDelta(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("TimeToExpiration": )"; - builder << writer.timeToExpiration(); + builder << ", "; + builder << R"("OptionDelta": )"; + builder << writer.optionDelta(); - builder << ", "; - builder << R"("RiskFreeRate": )"; - builder << writer.riskFreeRate(); + builder << ", "; + builder << R"("TimeToExpiration": )"; + builder << writer.timeToExpiration(); - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("RiskFreeRate": )"; + builder << writer.riskFreeRate(); - builder << ", "; - builder << R"("LastQty": )"; - builder << +writer.lastQty(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("CumQty": )"; - builder << +writer.cumQty(); + builder << ", "; + builder << R"("LastQty": )"; + builder << +writer.lastQty(); - builder << ", "; - builder << R"("SideTradeID": )"; - builder << +writer.sideTradeID(); + builder << ", "; + builder << R"("CumQty": )"; + builder << +writer.cumQty(); - builder << ", "; - builder << R"("TradeDate": )"; - builder << +writer.tradeDate(); + builder << ", "; + builder << R"("SideTradeID": )"; + builder << +writer.sideTradeID(); - builder << ", "; - builder << R"("OrdStatus": )"; - builder << '"' << writer.ordStatus() << '"'; + builder << ", "; + builder << R"("TradeDate": )"; + builder << +writer.tradeDate(); - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + builder << ", "; + builder << R"("OrdStatus": )"; + builder << '"' << writer.ordStatus() << '"'; - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoFills": [)"; - writer.noFills().forEach([&](NoFills &noFills) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noFills; - }); - builder << ']'; - } + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderEvents": [)"; - writer.noOrderEvents().forEach([&](NoOrderEvents &noOrderEvents) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderEvents; - }); - builder << ']'; - } + builder << ", "; + builder << R"("SettlDate": )"; + builder << +writer.settlDate(); - builder << '}'; + builder << ", "; + builder << R"("CalculatedCcyLastQty": )"; + if (writer.calculatedCcyLastQtyInActingVersion()) + { + builder << writer.calculatedCcyLastQty(); + } + else + { + builder << "{}"; + } - return builder; - } + builder << ", "; + builder << R"("GrossTradeAmt": )"; + if (writer.grossTradeAmtInActingVersion()) + { + builder << writer.grossTradeAmt(); + } + else + { + builder << "{}"; + } - void skip() { - noFills().forEach([](NoFills e) { e.skip(); }); - noOrderEvents().forEach([](NoOrderEvents e) { e.skip(); }); - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoFills": [)"; + writer.noFills().forEach( + [&](NoFills &noFills) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noFills; + }); + builder << ']'; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderEvents": [)"; + writer.noOrderEvents().forEach( + [&](NoOrderEvents &noOrderEvents) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderEvents; + }); + builder << ']'; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoFillsLength = 0, std::size_t NoOrderEventsLength = 0) { + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noFillsGroup { noFills() }; + while (noFillsGroup.hasNext()) + { + noFillsGroup.next().skip(); + } + auto &noOrderEventsGroup { noOrderEvents() }; + while (noOrderEventsGroup.hasNext()) + { + noOrderEventsGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noFillsLength = 0, + std::size_t noOrderEventsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoFills::sbeHeaderSize(); - if (NoFillsLength > 254) { - throw std::runtime_error( - "NoFillsLength outside of allowed range [E110]"); - } - length += NoFillsLength * NoFills::sbeBlockLength(); + length += NoFills::sbeHeaderSize(); + if (noFillsLength > 254LL) + { + throw std::runtime_error("noFillsLength outside of allowed range [E110]"); + } + length += noFillsLength *NoFills::sbeBlockLength(); - length += NoOrderEvents::sbeHeaderSize(); - if (NoOrderEventsLength > 254) { - throw std::runtime_error( - "NoOrderEventsLength outside of allowed range [E110]"); - } - length += NoOrderEventsLength * NoOrderEvents::sbeBlockLength(); - return length; + length += NoOrderEvents::sbeHeaderSize(); + if (noOrderEventsLength > 254LL) + { + throw std::runtime_error("noOrderEventsLength outside of allowed range [E110]"); + } + length += noOrderEventsLength *NoOrderEvents::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ExpCycle.h b/src/lib/orderman/ilink3/generated/ExpCycle.h index 5599898f4..f36b1264d 100644 --- a/src/lib/orderman/ilink3/generated/ExpCycle.h +++ b/src/lib/orderman/ilink3/generated/ExpCycle.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_EXPCYCLE_H_ #define _ILINKBINARY_EXPCYCLE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class ExpCycle { - public: - enum Value { - ExpireOnTradingSessionClose = (std::uint8_t)0, - Expirationatgivendate = (std::uint8_t)2, - NULL_VALUE = (std::uint8_t)255 - }; +class ExpCycle +{ +public: + enum Value + { + ExpireOnTradingSessionClose = static_cast(0), + Expirationatgivendate = static_cast(2), + NULL_VALUE = static_cast(255) + }; - static ExpCycle::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return ExpireOnTradingSessionClose; - case 2: - return Expirationatgivendate; - case 255: - return NULL_VALUE; - } + static ExpCycle::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return ExpireOnTradingSessionClose; + case static_cast(2): return Expirationatgivendate; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ExpCycle [E103]"); - } + throw std::runtime_error("unknown value for enum ExpCycle [E103]"); + } - static const char *c_str(const ExpCycle::Value value) { - switch (value) { - case ExpireOnTradingSessionClose: - return "ExpireOnTradingSessionClose"; - case Expirationatgivendate: - return "Expirationatgivendate"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ExpCycle::Value value) + { + switch (value) + { + case ExpireOnTradingSessionClose: return "ExpireOnTradingSessionClose"; + case Expirationatgivendate: return "Expirationatgivendate"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum ExpCycle [E103]:"); - } + throw std::runtime_error("unknown value for enum ExpCycle [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ExpCycle::Value m) { - return os << ExpCycle::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ExpCycle::Value m) + { + return os << ExpCycle::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/FTI.h b/src/lib/orderman/ilink3/generated/FTI.h index f8a3954d0..9750b78c2 100644 --- a/src/lib/orderman/ilink3/generated/FTI.h +++ b/src/lib/orderman/ilink3/generated/FTI.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_FTI_H_ #define _ILINKBINARY_FTI_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class FTI { - public: - enum Value { - Backup = (std::uint8_t)0, - Primary = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class FTI +{ +public: + enum Value + { + Backup = static_cast(0), + Primary = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static FTI::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Backup; - case 1: - return Primary; - case 255: - return NULL_VALUE; - } + static FTI::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Backup; + case static_cast(1): return Primary; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum FTI [E103]"); - } + throw std::runtime_error("unknown value for enum FTI [E103]"); + } - static const char *c_str(const FTI::Value value) { - switch (value) { - case Backup: - return "Backup"; - case Primary: - return "Primary"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const FTI::Value value) + { + switch (value) + { + case Backup: return "Backup"; + case Primary: return "Primary"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum FTI [E103]:"); - } + throw std::runtime_error("unknown value for enum FTI [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, FTI::Value m) { - return os << FTI::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, FTI::Value m) + { + return os << FTI::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/GroupSize.h b/src/lib/orderman/ilink3/generated/GroupSize.h index 81689203a..194cf92d5 100644 --- a/src/lib/orderman/ilink3/generated/GroupSize.h +++ b/src/lib/orderman/ilink3/generated/GroupSize.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,228 +86,276 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace iLinkBinary { -class GroupSize { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class GroupSize +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - GroupSize() = default; + GroupSize() = default; - GroupSize( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_actingVersion(actingVersion) { - if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 3) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + GroupSize( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_actingVersion(actingVersion) + { + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 3) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - GroupSize( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : GroupSize(buffer, 0, bufferLength, actingVersion) {} + GroupSize( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + GroupSize(buffer, 0, bufferLength, actingVersion) + { + } - GroupSize(char *buffer, const std::uint64_t bufferLength) - : GroupSize(buffer, 0, bufferLength, sbeSchemaVersion()) {} + GroupSize( + char *buffer, + const std::uint64_t bufferLength) : + GroupSize(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - GroupSize &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = GroupSize(buffer, offset, bufferLength, actingVersion); - } + GroupSize &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = GroupSize(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 3; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static const char * - blockLengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *blockLengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t blockLengthId() SBE_NOEXCEPT { - return -1; - } + static SBE_CONSTEXPR std::uint16_t blockLengthId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - blockLengthSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t blockLengthSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool blockLengthInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool blockLengthInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= blockLengthSinceVersion(); + return m_actingVersion >= blockLengthSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - blockLengthEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t blockLengthEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t blockLengthNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t blockLengthNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t blockLengthMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t blockLengthMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t blockLengthMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t blockLengthMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t blockLengthEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t blockLengthEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t blockLength() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t blockLength() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - GroupSize &blockLength(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); - return *this; - } + GroupSize &blockLength(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - numInGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *numInGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t numInGroupId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t numInGroupId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - numInGroupSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t numInGroupSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool numInGroupInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool numInGroupInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= numInGroupSinceVersion(); + return m_actingVersion >= numInGroupSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - numInGroupEncodingOffset() SBE_NOEXCEPT { - return 2; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t numInGroupEncodingOffset() SBE_NOEXCEPT + { + return 2; + } - static SBE_CONSTEXPR std::uint8_t numInGroupNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t numInGroupNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t numInGroupMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t numInGroupMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t numInGroupMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t numInGroupMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t numInGroupEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t numInGroupEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t numInGroup() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t numInGroup() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint8_t)); + return (val); + } - GroupSize &numInGroup(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint8_t)); - return *this; - } + GroupSize &numInGroup(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint8_t)); + return *this; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, GroupSize writer) { - builder << '{'; - builder << R"("blockLength": )"; - builder << +writer.blockLength(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, GroupSize writer) +{ + builder << '{'; + builder << R"("blockLength": )"; + builder << +writer.blockLength(); - builder << ", "; - builder << R"("numInGroup": )"; - builder << +writer.numInGroup(); + builder << ", "; + builder << R"("numInGroup": )"; + builder << +writer.numInGroup(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/KeepAliveLapsed.h b/src/lib/orderman/ilink3/generated/KeepAliveLapsed.h index 07bff4125..4d103a3e4 100644 --- a/src/lib/orderman/ilink3/generated/KeepAliveLapsed.h +++ b/src/lib/orderman/ilink3/generated/KeepAliveLapsed.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_KEEPALIVELAPSED_H_ #define _ILINKBINARY_KEEPALIVELAPSED_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,48 +25,48 @@ namespace iLinkBinary { -class KeepAliveLapsed { - public: - enum Value { - NotLapsed = (std::uint8_t)0, - Lapsed = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class KeepAliveLapsed +{ +public: + enum Value + { + NotLapsed = static_cast(0), + Lapsed = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static KeepAliveLapsed::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return NotLapsed; - case 1: - return Lapsed; - case 255: - return NULL_VALUE; - } + static KeepAliveLapsed::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return NotLapsed; + case static_cast(1): return Lapsed; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum KeepAliveLapsed [E103]"); - } + throw std::runtime_error("unknown value for enum KeepAliveLapsed [E103]"); + } - static const char *c_str(const KeepAliveLapsed::Value value) { - switch (value) { - case NotLapsed: - return "NotLapsed"; - case Lapsed: - return "Lapsed"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const KeepAliveLapsed::Value value) + { + switch (value) + { + case NotLapsed: return "NotLapsed"; + case Lapsed: return "Lapsed"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum KeepAliveLapsed [E103]:"); - } + throw std::runtime_error("unknown value for enum KeepAliveLapsed [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, KeepAliveLapsed::Value m) { - return os << KeepAliveLapsed::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, KeepAliveLapsed::Value m) + { + return os << KeepAliveLapsed::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ListUpdAct.h b/src/lib/orderman/ilink3/generated/ListUpdAct.h index 32491bafb..6b0db9aca 100644 --- a/src/lib/orderman/ilink3/generated/ListUpdAct.h +++ b/src/lib/orderman/ilink3/generated/ListUpdAct.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_LISTUPDACT_H_ #define _ILINKBINARY_LISTUPDACT_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,43 +25,48 @@ namespace iLinkBinary { -class ListUpdAct { - public: - enum Value { Add = (char)65, Delete = (char)68, NULL_VALUE = (char)0 }; +class ListUpdAct +{ +public: + enum Value + { + Add = static_cast(65), + Delete = static_cast(68), + NULL_VALUE = static_cast(0) + }; - static ListUpdAct::Value get(const char value) { - switch (value) { - case 65: - return Add; - case 68: - return Delete; - case 0: - return NULL_VALUE; - } + static ListUpdAct::Value get(const char value) + { + switch (value) + { + case static_cast(65): return Add; + case static_cast(68): return Delete; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ListUpdAct [E103]"); - } + throw std::runtime_error("unknown value for enum ListUpdAct [E103]"); + } - static const char *c_str(const ListUpdAct::Value value) { - switch (value) { - case Add: - return "Add"; - case Delete: - return "Delete"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ListUpdAct::Value value) + { + switch (value) + { + case Add: return "Add"; + case Delete: return "Delete"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum ListUpdAct [E103]:"); - } + throw std::runtime_error("unknown value for enum ListUpdAct [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ListUpdAct::Value m) { - return os << ListUpdAct::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ListUpdAct::Value m) + { + return os << ListUpdAct::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ManualOrdInd.h b/src/lib/orderman/ilink3/generated/ManualOrdInd.h index 454f8b6ab..08a5f3898 100644 --- a/src/lib/orderman/ilink3/generated/ManualOrdInd.h +++ b/src/lib/orderman/ilink3/generated/ManualOrdInd.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MANUALORDIND_H_ #define _ILINKBINARY_MANUALORDIND_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class ManualOrdInd { - public: - enum Value { - Automated = (std::uint8_t)0, - Manual = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class ManualOrdInd +{ +public: + enum Value + { + Automated = static_cast(0), + Manual = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static ManualOrdInd::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Automated; - case 1: - return Manual; - case 255: - return NULL_VALUE; - } + static ManualOrdInd::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Automated; + case static_cast(1): return Manual; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ManualOrdInd [E103]"); - } + throw std::runtime_error("unknown value for enum ManualOrdInd [E103]"); + } - static const char *c_str(const ManualOrdInd::Value value) { - switch (value) { - case Automated: - return "Automated"; - case Manual: - return "Manual"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ManualOrdInd::Value value) + { + switch (value) + { + case Automated: return "Automated"; + case Manual: return "Manual"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum ManualOrdInd [E103]:"); - } + throw std::runtime_error("unknown value for enum ManualOrdInd [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ManualOrdInd::Value m) { - return os << ManualOrdInd::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ManualOrdInd::Value m) + { + return os << ManualOrdInd::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ManualOrdIndReq.h b/src/lib/orderman/ilink3/generated/ManualOrdIndReq.h index e16cff4af..9ee9f76a6 100644 --- a/src/lib/orderman/ilink3/generated/ManualOrdIndReq.h +++ b/src/lib/orderman/ilink3/generated/ManualOrdIndReq.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MANUALORDINDREQ_H_ #define _ILINKBINARY_MANUALORDINDREQ_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,48 +25,48 @@ namespace iLinkBinary { -class ManualOrdIndReq { - public: - enum Value { - Automated = (std::uint8_t)0, - Manual = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class ManualOrdIndReq +{ +public: + enum Value + { + Automated = static_cast(0), + Manual = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static ManualOrdIndReq::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Automated; - case 1: - return Manual; - case 255: - return NULL_VALUE; - } + static ManualOrdIndReq::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Automated; + case static_cast(1): return Manual; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ManualOrdIndReq [E103]"); - } + throw std::runtime_error("unknown value for enum ManualOrdIndReq [E103]"); + } - static const char *c_str(const ManualOrdIndReq::Value value) { - switch (value) { - case Automated: - return "Automated"; - case Manual: - return "Manual"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ManualOrdIndReq::Value value) + { + switch (value) + { + case Automated: return "Automated"; + case Manual: return "Manual"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum ManualOrdIndReq [E103]:"); - } + throw std::runtime_error("unknown value for enum ManualOrdIndReq [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ManualOrdIndReq::Value m) { - return os << ManualOrdIndReq::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ManualOrdIndReq::Value m) + { + return os << ManualOrdIndReq::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassActionOrdTyp.h b/src/lib/orderman/ilink3/generated/MassActionOrdTyp.h index cfb16b519..a5d854b1b 100644 --- a/src/lib/orderman/ilink3/generated/MassActionOrdTyp.h +++ b/src/lib/orderman/ilink3/generated/MassActionOrdTyp.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MASSACTIONORDTYP_H_ #define _ILINKBINARY_MASSACTIONORDTYP_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,45 +25,48 @@ namespace iLinkBinary { -class MassActionOrdTyp { - public: - enum Value { Limit = (char)50, StopLimit = (char)52, NULL_VALUE = (char)0 }; +class MassActionOrdTyp +{ +public: + enum Value + { + Limit = static_cast(50), + StopLimit = static_cast(52), + NULL_VALUE = static_cast(48) + }; - static MassActionOrdTyp::Value get(const char value) { - switch (value) { - case 50: - return Limit; - case 52: - return StopLimit; - case 0: - return NULL_VALUE; - } + static MassActionOrdTyp::Value get(const char value) + { + switch (value) + { + case static_cast(50): return Limit; + case static_cast(52): return StopLimit; + case static_cast(48): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum MassActionOrdTyp [E103]"); - } + throw std::runtime_error("unknown value for enum MassActionOrdTyp [E103]"); + } - static const char *c_str(const MassActionOrdTyp::Value value) { - switch (value) { - case Limit: - return "Limit"; - case StopLimit: - return "StopLimit"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MassActionOrdTyp::Value value) + { + switch (value) + { + case Limit: return "Limit"; + case StopLimit: return "StopLimit"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum MassActionOrdTyp [E103]:"); - } + throw std::runtime_error("unknown value for enum MassActionOrdTyp [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, MassActionOrdTyp::Value m) { - return os << MassActionOrdTyp::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, MassActionOrdTyp::Value m) + { + return os << MassActionOrdTyp::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassActionResponse.h b/src/lib/orderman/ilink3/generated/MassActionResponse.h index 66e908635..fe31f60ce 100644 --- a/src/lib/orderman/ilink3/generated/MassActionResponse.h +++ b/src/lib/orderman/ilink3/generated/MassActionResponse.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MASSACTIONRESPONSE_H_ #define _ILINKBINARY_MASSACTIONRESPONSE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,49 +25,48 @@ namespace iLinkBinary { -class MassActionResponse { - public: - enum Value { - Rejected = (std::uint8_t)0, - Accepted = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class MassActionResponse +{ +public: + enum Value + { + Rejected = static_cast(0), + Accepted = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static MassActionResponse::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Rejected; - case 1: - return Accepted; - case 255: - return NULL_VALUE; - } + static MassActionResponse::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Rejected; + case static_cast(1): return Accepted; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum MassActionResponse [E103]"); - } + throw std::runtime_error("unknown value for enum MassActionResponse [E103]"); + } - static const char *c_str(const MassActionResponse::Value value) { - switch (value) { - case Rejected: - return "Rejected"; - case Accepted: - return "Accepted"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MassActionResponse::Value value) + { + switch (value) + { + case Rejected: return "Rejected"; + case Accepted: return "Accepted"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum MassActionResponse [E103]:"); - } + throw std::runtime_error("unknown value for enum MassActionResponse [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, MassActionResponse::Value m) { - return os << MassActionResponse::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, MassActionResponse::Value m) + { + return os << MassActionResponse::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassActionScope.h b/src/lib/orderman/ilink3/generated/MassActionScope.h index d42065d6a..f0c912359 100644 --- a/src/lib/orderman/ilink3/generated/MassActionScope.h +++ b/src/lib/orderman/ilink3/generated/MassActionScope.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MASSACTIONSCOPE_H_ #define _ILINKBINARY_MASSACTIONSCOPE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,63 +25,57 @@ namespace iLinkBinary { -class MassActionScope { - public: - enum Value { - Instrument = (std::uint8_t)1, - All = (std::uint8_t)7, - MarketSegmentID = (std::uint8_t)9, - InstrumentGroup = (std::uint8_t)10, - QuoteSetID = (std::uint8_t)100, - NULL_VALUE = (std::uint8_t)255 - }; +class MassActionScope +{ +public: + enum Value + { + Instrument = static_cast(1), + All = static_cast(7), + MarketSegmentID = static_cast(9), + InstrumentGroup = static_cast(10), + QuoteSetID = static_cast(100), + NULL_VALUE = static_cast(255) + }; - static MassActionScope::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return Instrument; - case 7: - return All; - case 9: - return MarketSegmentID; - case 10: - return InstrumentGroup; - case 100: - return QuoteSetID; - case 255: - return NULL_VALUE; - } + static MassActionScope::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return Instrument; + case static_cast(7): return All; + case static_cast(9): return MarketSegmentID; + case static_cast(10): return InstrumentGroup; + case static_cast(100): return QuoteSetID; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum MassActionScope [E103]"); - } + throw std::runtime_error("unknown value for enum MassActionScope [E103]"); + } - static const char *c_str(const MassActionScope::Value value) { - switch (value) { - case Instrument: - return "Instrument"; - case All: - return "All"; - case MarketSegmentID: - return "MarketSegmentID"; - case InstrumentGroup: - return "InstrumentGroup"; - case QuoteSetID: - return "QuoteSetID"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MassActionScope::Value value) + { + switch (value) + { + case Instrument: return "Instrument"; + case All: return "All"; + case MarketSegmentID: return "MarketSegmentID"; + case InstrumentGroup: return "InstrumentGroup"; + case QuoteSetID: return "QuoteSetID"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum MassActionScope [E103]:"); - } + throw std::runtime_error("unknown value for enum MassActionScope [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, MassActionScope::Value m) { - return os << MassActionScope::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, MassActionScope::Value m) + { + return os << MassActionScope::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassCancelTIF.h b/src/lib/orderman/ilink3/generated/MassCancelTIF.h index 3553ec9ea..f1a641c66 100644 --- a/src/lib/orderman/ilink3/generated/MassCancelTIF.h +++ b/src/lib/orderman/ilink3/generated/MassCancelTIF.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MASSCANCELTIF_H_ #define _ILINKBINARY_MASSCANCELTIF_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,52 +25,51 @@ namespace iLinkBinary { -class MassCancelTIF { - public: - enum Value { - Day = (std::uint8_t)0, - GoodTillCancel = (std::uint8_t)1, - GoodTillDate = (std::uint8_t)6, - NULL_VALUE = (std::uint8_t)255 - }; +class MassCancelTIF +{ +public: + enum Value + { + Day = static_cast(0), + GoodTillCancel = static_cast(1), + GoodTillDate = static_cast(6), + NULL_VALUE = static_cast(255) + }; - static MassCancelTIF::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Day; - case 1: - return GoodTillCancel; - case 6: - return GoodTillDate; - case 255: - return NULL_VALUE; - } + static MassCancelTIF::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Day; + case static_cast(1): return GoodTillCancel; + case static_cast(6): return GoodTillDate; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum MassCancelTIF [E103]"); - } + throw std::runtime_error("unknown value for enum MassCancelTIF [E103]"); + } - static const char *c_str(const MassCancelTIF::Value value) { - switch (value) { - case Day: - return "Day"; - case GoodTillCancel: - return "GoodTillCancel"; - case GoodTillDate: - return "GoodTillDate"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MassCancelTIF::Value value) + { + switch (value) + { + case Day: return "Day"; + case GoodTillCancel: return "GoodTillCancel"; + case GoodTillDate: return "GoodTillDate"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum MassCancelTIF [E103]:"); - } + throw std::runtime_error("unknown value for enum MassCancelTIF [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, MassCancelTIF::Value m) { - return os << MassCancelTIF::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, MassCancelTIF::Value m) + { + return os << MassCancelTIF::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassCxlReqTyp.h b/src/lib/orderman/ilink3/generated/MassCxlReqTyp.h index ae8676159..692144b0a 100644 --- a/src/lib/orderman/ilink3/generated/MassCxlReqTyp.h +++ b/src/lib/orderman/ilink3/generated/MassCxlReqTyp.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MASSCXLREQTYP_H_ #define _ILINKBINARY_MASSCXLREQTYP_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class MassCxlReqTyp { - public: - enum Value { - SenderSubID = (std::uint8_t)100, - Account = (std::uint8_t)101, - NULL_VALUE = (std::uint8_t)255 - }; +class MassCxlReqTyp +{ +public: + enum Value + { + SenderSubID = static_cast(100), + Account = static_cast(101), + NULL_VALUE = static_cast(255) + }; - static MassCxlReqTyp::Value get(const std::uint8_t value) { - switch (value) { - case 100: - return SenderSubID; - case 101: - return Account; - case 255: - return NULL_VALUE; - } + static MassCxlReqTyp::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(100): return SenderSubID; + case static_cast(101): return Account; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum MassCxlReqTyp [E103]"); - } + throw std::runtime_error("unknown value for enum MassCxlReqTyp [E103]"); + } - static const char *c_str(const MassCxlReqTyp::Value value) { - switch (value) { - case SenderSubID: - return "SenderSubID"; - case Account: - return "Account"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MassCxlReqTyp::Value value) + { + switch (value) + { + case SenderSubID: return "SenderSubID"; + case Account: return "Account"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum MassCxlReqTyp [E103]:"); - } + throw std::runtime_error("unknown value for enum MassCxlReqTyp [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, MassCxlReqTyp::Value m) { - return os << MassCxlReqTyp::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, MassCxlReqTyp::Value m) + { + return os << MassCxlReqTyp::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassQuote517.h b/src/lib/orderman/ilink3/generated/MassQuote517.h index f850ca5ac..fd63c882f 100644 --- a/src/lib/orderman/ilink3/generated/MassQuote517.h +++ b/src/lib/orderman/ilink3/generated/MassQuote517.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2265 +86,2793 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class MassQuote517 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - MassQuote517() = default; - - MassQuote517( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - MassQuote517(char *buffer, const std::uint64_t bufferLength) - : MassQuote517( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - MassQuote517( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MassQuote517( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)92; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)517; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "i"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - MassQuote517 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MassQuote517( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - MassQuote517 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = MassQuote517( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - MassQuote517 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = MassQuote517( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD std::uint64_t decodeLength() const { - MassQuote517 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - MassQuote517 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - MassQuote517 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - MassQuote517 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - MassQuote517 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } - - MassQuote517 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } - - MassQuote517 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - MassQuote517 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } - - return *this; - } -#else - MassQuote517 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t quoteReqIDId() SBE_NOEXCEPT { - return 131; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteReqIDEncodingOffset() SBE_NOEXCEPT { - return 41; - } - - static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t quoteReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - MassQuote517 "eReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 49; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); - return (val); - } - - MassQuote517 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 49, - sizeof(char) * static_cast(length)); - return length; - } - - MassQuote517 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - MassQuote517 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } - - return *this; - } -#else - MassQuote517 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t quoteIDId() SBE_NOEXCEPT { return 117; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteIDEncodingOffset() SBE_NOEXCEPT { - return 54; - } - - static SBE_CONSTEXPR std::uint32_t quoteIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t quoteID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 54, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - MassQuote517 "eID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 54, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *TotNoQuoteEntriesMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t totNoQuoteEntriesId() SBE_NOEXCEPT { - return 304; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNoQuoteEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool totNoQuoteEntriesInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= totNoQuoteEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNoQuoteEntriesEncodingOffset() SBE_NOEXCEPT { - return 58; - } - - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t totNoQuoteEntries() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 58, sizeof(std::uint8_t)); - return (val); - } - - MassQuote517 &totNoQuoteEntries(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 58, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MMProtectionResetMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mMProtectionResetId() SBE_NOEXCEPT { - return 9773; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mMProtectionResetSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mMProtectionResetInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mMProtectionResetSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mMProtectionResetEncodingOffset() SBE_NOEXCEPT { - return 59; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mMProtectionResetEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 59, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - MassQuote517 & - mMProtectionReset(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 59, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= liquidityFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 60; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - MassQuote517 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 60, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= shortSaleTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 61; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } - - MassQuote517 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - ReservedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t reservedId() SBE_NOEXCEPT { return 5187; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - reservedSinceVersion() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD bool reservedInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= reservedSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - reservedEncodingOffset() SBE_NOEXCEPT { - return 62; - } - - static SBE_CONSTEXPR char reservedNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char reservedMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char reservedMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t reservedEncodingLength() SBE_NOEXCEPT { - return 30; - } - - static SBE_CONSTEXPR std::uint64_t reservedLength() SBE_NOEXCEPT { - return 30; - } - - SBE_NODISCARD const char *reserved() const SBE_NOEXCEPT { - if (m_actingVersion < 5) { - return nullptr; - } - - return m_buffer + m_offset + 62; - } - - SBE_NODISCARD char *reserved() SBE_NOEXCEPT { - if (m_actingVersion < 5) { - return nullptr; - } - - return m_buffer + m_offset + 62; - } - - SBE_NODISCARD char reserved(const std::uint64_t index) const { - if (index >= 30) { - throw std::runtime_error("index out of range for reserved [E104]"); - } - - if (m_actingVersion < 5) { - return (char)0; - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 62 + (index * 1), sizeof(char)); - return (val); - } - - MassQuote517 &reserved(const std::uint64_t index, const char value) { - if (index >= 30) { - throw std::runtime_error("index out of range for reserved [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 62 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getReserved(char *const dst, const std::uint64_t length) const { - if (length > 30) { - throw std::runtime_error("length too large for getReserved [E106]"); - } - - if (m_actingVersion < 5) { - return 0; - } - - std::memcpy( - dst, m_buffer + m_offset + 62, - sizeof(char) * static_cast(length)); - return length; - } - - MassQuote517 &putReserved(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 62, src, sizeof(char) * 30); - return *this; - } - - SBE_NODISCARD std::string getReservedAsString() const { - const char *buffer = m_buffer + m_offset + 62; - size_t length = 0; - - for (; length < 30 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getReservedAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getReservedAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getReservedAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 62; - size_t length = 0; - - for (; length < 30 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - MassQuote517 &putReserved(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error("string too large for putReserved [E106]"); - } - - std::memcpy(m_buffer + m_offset + 62, str.data(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 62 + start] = 0; - } - - return *this; - } -#else - MassQuote517 &putReserved(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error("string too large for putReserved [E106]"); - } - - std::memcpy(m_buffer + m_offset + 62, str.c_str(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 62 + start] = 0; - } - - return *this; - } -#endif - - class NoQuoteEntries { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)38); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 38; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 38; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { +class MassQuote517 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(123); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(517); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + MassQuote517() = default; + + MassQuote517( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + MassQuote517(char *buffer, const std::uint64_t bufferLength) : + MassQuote517(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + MassQuote517( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MassQuote517(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(123); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(517); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "i"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + MassQuote517 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MassQuote517(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + MassQuote517 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = MassQuote517( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + MassQuote517 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = MassQuote517(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + MassQuote517 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + } + return position; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MassQuote517 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoQuoteEntries &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - return *this; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static const char * - BidPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t bidPxId() SBE_NOEXCEPT { return 132; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - bidPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool bidPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= bidPxSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - bidPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICENULL9 m_bidPx; + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - public: - SBE_NODISCARD PRICENULL9 &bidPx() { - m_bidPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_bidPx; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - SBE_NODISCARD static const char * - OfferPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::uint16_t offerPxId() SBE_NOEXCEPT { - return 133; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - offerPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SBE_NODISCARD bool offerPxInActingVersion() SBE_NOEXCEPT { + MassQuote517 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= offerPxSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - offerPxEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - PRICENULL9 m_offerPx; + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - public: - SBE_NODISCARD PRICENULL9 &offerPx() { - m_offerPx.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_offerPx; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - SBE_NODISCARD static const char *QuoteEntryIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::uint16_t quoteEntryIDId() SBE_NOEXCEPT { - return 299; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteEntryIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SBE_NODISCARD bool quoteEntryIDInActingVersion() SBE_NOEXCEPT { + MassQuote517 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteEntryIDSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteEntryIDEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - static SBE_CONSTEXPR std::uint32_t quoteEntryIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - static SBE_CONSTEXPR std::size_t - quoteEntryIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + MassQuote517 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD std::uint32_t quoteEntryID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - NoQuoteEntries "eEntryID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint32_t)); - return *this; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { - return 48; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 20; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NoQuoteEntries &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::int32_t)); - return *this; - } + MassQuote517 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - BidSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t bidSizeId() SBE_NOEXCEPT { - return 134; - } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - bidSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool bidSizeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= bidSizeSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - bidSizeEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t bidSize() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteEntries &bidSize(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - OfferSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t offerSizeId() SBE_NOEXCEPT { - return 135; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - offerSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool offerSizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= offerSizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - offerSizeEncodingOffset() SBE_NOEXCEPT { - return 28; - } - - static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t offerSize() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteEntries &offerSize(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *UnderlyingSecurityIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t underlyingSecurityIDId() SBE_NOEXCEPT { - return 309; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingSecurityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool underlyingSecurityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= underlyingSecurityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingSecurityIDEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - static SBE_CONSTEXPR std::int32_t - underlyingSecurityIDNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t - underlyingSecurityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t - underlyingSecurityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - underlyingSecurityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t underlyingSecurityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteEntries & - underlyingSecurityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDId() SBE_NOEXCEPT { - return 302; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteSetIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteSetIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteSetIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteSetIDEncodingOffset() SBE_NOEXCEPT { - return 36; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t quoteSetID() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoQuoteEntries "eSetID(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 36, &val, sizeof(std::uint16_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoQuoteEntries writer) { - builder << '{'; - builder << R"("BidPx": )"; - builder << writer.bidPx(); - - builder << ", "; - builder << R"("OfferPx": )"; - builder << writer.offerPx(); - - builder << ", "; - builder << R"("QuoteEntryID": )"; - builder << +writer.quoteEntryID(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("BidSize": )"; - builder << +writer.bidSize(); - - builder << ", "; - builder << R"("OfferSize": )"; - builder << +writer.offerSize(); - - builder << ", "; - builder << R"("UnderlyingSecurityID": )"; - builder << +writer.underlyingSecurityID(); - - builder << ", "; - builder << R"("QuoteSetID": )"; - builder << +writer.quoteSetID(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoQuoteEntries m_noQuoteEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoQuoteEntriesId() SBE_NOEXCEPT { - return 295; - } - - SBE_NODISCARD inline NoQuoteEntries &noQuoteEntries() { - m_noQuoteEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } - - NoQuoteEntries &noQuoteEntriesCount(const std::uint8_t count) { - m_noQuoteEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noQuoteEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noQuoteEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noQuoteEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, MassQuote517 _writer) { - MassQuote517 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MassQuote517", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("QuoteReqID": )"; - builder << +writer.quoteReqID(); - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("QuoteID": )"; - builder << +writer.quoteID(); - - builder << ", "; - builder << R"("TotNoQuoteEntries": )"; - builder << +writer.totNoQuoteEntries(); - - builder << ", "; - builder << R"("MMProtectionReset": )"; - builder << '"' << writer.mMProtectionReset() << '"'; - - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; - - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; - - builder << ", "; - builder << R"("Reserved": )"; - builder << '"' << writer.getReservedAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoQuoteEntries": [)"; - writer.noQuoteEntries().forEach([&](NoQuoteEntries &noQuoteEntries) { - if (atLeastOne) { - builder << ", "; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } + + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } + + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } + + MassQuote517 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } + + MassQuote517 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - atLeastOne = true; - builder << noQuoteEntries; - }); - builder << ']'; - } + } - builder << '}'; + return oss.str(); + } - return builder; - } + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - void skip() { - noQuoteEntries().forEach([](NoQuoteEntries e) { e.skip(); }); - } + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + return result; + } + #endif - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t NoQuoteEntriesLength = 0) { + #if __cplusplus >= 201703L + MassQuote517 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } + + return *this; + } + #else + MassQuote517 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteReqIDId() SBE_NOEXCEPT + { + return 131; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= quoteReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteReqIDEncodingOffset() SBE_NOEXCEPT + { + return 41; + } + + static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t quoteReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + MassQuote517 "eReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 49; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); + return (val); + } + + MassQuote517 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast(length)); + return length; + } + + MassQuote517 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + MassQuote517 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } + + return *this; + } + #else + MassQuote517 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteIDId() SBE_NOEXCEPT + { + return 117; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= quoteIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteIDEncodingOffset() SBE_NOEXCEPT + { + return 54; + } + + static SBE_CONSTEXPR std::uint32_t quoteIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t quoteID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 54, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + MassQuote517 "eID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 54, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *TotNoQuoteEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t totNoQuoteEntriesId() SBE_NOEXCEPT + { + return 304; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNoQuoteEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool totNoQuoteEntriesInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= totNoQuoteEntriesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingOffset() SBE_NOEXCEPT + { + return 58; + } + + static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t totNoQuoteEntries() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 58, sizeof(std::uint8_t)); + return (val); + } + + MassQuote517 &totNoQuoteEntries(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 58, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MMProtectionResetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mMProtectionResetId() SBE_NOEXCEPT + { + return 9773; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mMProtectionResetSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mMProtectionResetInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= mMProtectionResetSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mMProtectionResetEncodingOffset() SBE_NOEXCEPT + { + return 59; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mMProtectionResetEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t mMProtectionResetRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 59, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 59, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + MassQuote517 &mMProtectionReset(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 59, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= liquidityFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + MassQuote517 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 60, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= shortSaleTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 61; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } + + MassQuote517 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ReservedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t reservedId() SBE_NOEXCEPT + { + return 5187; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reservedSinceVersion() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD bool reservedInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reservedSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reservedEncodingOffset() SBE_NOEXCEPT + { + return 62; + } + + static SBE_CONSTEXPR char reservedNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char reservedMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char reservedMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t reservedEncodingLength() SBE_NOEXCEPT + { + return 30; + } + + static SBE_CONSTEXPR std::uint64_t reservedLength() SBE_NOEXCEPT + { + return 30; + } + + SBE_NODISCARD const char *reserved() const SBE_NOEXCEPT + { + if (m_actingVersion < 5) + { + return nullptr; + } + + return m_buffer + m_offset + 62; + } + + SBE_NODISCARD char *reserved() SBE_NOEXCEPT + { + if (m_actingVersion < 5) + { + return nullptr; + } + + return m_buffer + m_offset + 62; + } + + SBE_NODISCARD char reserved(const std::uint64_t index) const + { + if (index >= 30) + { + throw std::runtime_error("index out of range for reserved [E104]"); + } + + if (m_actingVersion < 5) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 62 + (index * 1), sizeof(char)); + return (val); + } + + MassQuote517 &reserved(const std::uint64_t index, const char value) + { + if (index >= 30) + { + throw std::runtime_error("index out of range for reserved [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 62 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getReserved(char *const dst, const std::uint64_t length) const + { + if (length > 30) + { + throw std::runtime_error("length too large for getReserved [E106]"); + } + + if (m_actingVersion < 5) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 62, sizeof(char) * static_cast(length)); + return length; + } + + MassQuote517 &putReserved(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 62, src, sizeof(char) * 30); + return *this; + } + + SBE_NODISCARD std::string getReservedAsString() const + { + const char *buffer = m_buffer + m_offset + 62; + std::size_t length = 0; + + for (; length < 30 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getReservedAsJsonEscapedString() + { + if (m_actingVersion < 5) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getReservedAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getReservedAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 62; + std::size_t length = 0; + + for (; length < 30 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + MassQuote517 &putReserved(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putReserved [E106]"); + } + + std::memcpy(m_buffer + m_offset + 62, str.data(), srcLength); + for (std::size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 62 + start] = 0; + } + + return *this; + } + #else + MassQuote517 &putReserved(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putReserved [E106]"); + } + + std::memcpy(m_buffer + m_offset + 62, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 62 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *Reserved1MetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t reserved1Id() SBE_NOEXCEPT + { + return 5239; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reserved1SinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool reserved1InActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reserved1SinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reserved1EncodingOffset() SBE_NOEXCEPT + { + return 92; + } + + static SBE_CONSTEXPR char reserved1NullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char reserved1MinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char reserved1MaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t reserved1EncodingLength() SBE_NOEXCEPT + { + return 30; + } + + static SBE_CONSTEXPR std::uint64_t reserved1Length() SBE_NOEXCEPT + { + return 30; + } + + SBE_NODISCARD const char *reserved1() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 92; + } + + SBE_NODISCARD char *reserved1() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 92; + } + + SBE_NODISCARD char reserved1(const std::uint64_t index) const + { + if (index >= 30) + { + throw std::runtime_error("index out of range for reserved1 [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 92 + (index * 1), sizeof(char)); + return (val); + } + + MassQuote517 &reserved1(const std::uint64_t index, const char value) + { + if (index >= 30) + { + throw std::runtime_error("index out of range for reserved1 [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 92 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getReserved1(char *const dst, const std::uint64_t length) const + { + if (length > 30) + { + throw std::runtime_error("length too large for getReserved1 [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 92, sizeof(char) * static_cast(length)); + return length; + } + + MassQuote517 &putReserved1(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 92, src, sizeof(char) * 30); + return *this; + } + + SBE_NODISCARD std::string getReserved1AsString() const + { + const char *buffer = m_buffer + m_offset + 92; + std::size_t length = 0; + + for (; length < 30 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getReserved1AsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getReserved1AsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getReserved1AsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 92; + std::size_t length = 0; + + for (; length < 30 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + MassQuote517 &putReserved1(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putReserved1 [E106]"); + } + + std::memcpy(m_buffer + m_offset + 92, str.data(), srcLength); + for (std::size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 92 + start] = 0; + } + + return *this; + } + #else + MassQuote517 &putReserved1(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putReserved1 [E106]"); + } + + std::memcpy(m_buffer + m_offset + 92, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 92 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *QuoteEntryOpenMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteEntryOpenId() SBE_NOEXCEPT + { + return 9182; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteEntryOpenSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool quoteEntryOpenInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= quoteEntryOpenSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryOpenEncodingOffset() SBE_NOEXCEPT + { + return 122; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryOpenEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t quoteEntryOpenRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 122, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value quoteEntryOpen() const + { + if (m_actingVersion < 8) + { + return BooleanNULL::NULL_VALUE; + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 122, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + MassQuote517 "eEntryOpen(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 122, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoQuoteEntries + { + private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; + + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } + + public: + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(38)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 38; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 38; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoQuoteEntries &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *BidPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t bidPxId() SBE_NOEXCEPT + { + return 132; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t bidPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool bidPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= bidPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t bidPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL9 m_bidPx; + +public: + SBE_NODISCARD PRICENULL9 &bidPx() + { + m_bidPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_bidPx; + } + + SBE_NODISCARD static const char *OfferPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t offerPxId() SBE_NOEXCEPT + { + return 133; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t offerPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool offerPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= offerPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t offerPxEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + +private: + PRICENULL9 m_offerPx; + +public: + SBE_NODISCARD PRICENULL9 &offerPx() + { + m_offerPx.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_offerPx; + } + + SBE_NODISCARD static const char *QuoteEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteEntryIDId() SBE_NOEXCEPT + { + return 299; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteEntryIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteEntryIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteEntryIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::uint32_t quoteEntryIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t quoteEntryID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries "eEntryID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= securityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *BidSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t bidSizeId() SBE_NOEXCEPT + { + return 134; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t bidSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool bidSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= bidSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t bidSizeEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t bidSize() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries &bidSize(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OfferSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t offerSizeId() SBE_NOEXCEPT + { + return 135; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t offerSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool offerSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= offerSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t offerSizeEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t offerSize() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries &offerSize(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UnderlyingSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t underlyingSecurityIDId() SBE_NOEXCEPT + { + return 309; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingSecurityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool underlyingSecurityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= underlyingSecurityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingSecurityIDEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + + static SBE_CONSTEXPR std::int32_t underlyingSecurityIDNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t underlyingSecurityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t underlyingSecurityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t underlyingSecurityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t underlyingSecurityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries &underlyingSecurityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDId() SBE_NOEXCEPT + { + return 302; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteSetIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteSetIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteSetIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteSetIDEncodingOffset() SBE_NOEXCEPT + { + return 36; + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t quoteSetID() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 36, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoQuoteEntries "eSetID(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 36, &val, sizeof(std::uint16_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoQuoteEntries writer) + { + builder << '{'; + builder << R"("BidPx": )"; + builder << writer.bidPx(); + + builder << ", "; + builder << R"("OfferPx": )"; + builder << writer.offerPx(); + + builder << ", "; + builder << R"("QuoteEntryID": )"; + builder << +writer.quoteEntryID(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("BidSize": )"; + builder << +writer.bidSize(); + + builder << ", "; + builder << R"("OfferSize": )"; + builder << +writer.offerSize(); + + builder << ", "; + builder << R"("UnderlyingSecurityID": )"; + builder << +writer.underlyingSecurityID(); + + builder << ", "; + builder << R"("QuoteSetID": )"; + builder << +writer.quoteSetID(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoQuoteEntries::sbeHeaderSize(); - if (NoQuoteEntriesLength > 254) { - throw std::runtime_error( - "NoQuoteEntriesLength outside of allowed range [E110]"); - } - length += NoQuoteEntriesLength * NoQuoteEntries::sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } + } + }; + +private: + NoQuoteEntries m_noQuoteEntries; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoQuoteEntriesId() SBE_NOEXCEPT + { + return 295; + } + + SBE_NODISCARD inline NoQuoteEntries &noQuoteEntries() + { + m_noQuoteEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteEntries; + } + + NoQuoteEntries &noQuoteEntriesCount(const std::uint8_t count) + { + m_noQuoteEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteEntries; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noQuoteEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noQuoteEntriesInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noQuoteEntriesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, MassQuote517 _writer) +{ + MassQuote517 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "MassQuote517", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("QuoteReqID": )"; + builder << +writer.quoteReqID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("QuoteID": )"; + builder << +writer.quoteID(); + + builder << ", "; + builder << R"("TotNoQuoteEntries": )"; + builder << +writer.totNoQuoteEntries(); + + builder << ", "; + builder << R"("MMProtectionReset": )"; + builder << '"' << writer.mMProtectionReset() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("Reserved": )"; + builder << '"' << + writer.getReservedAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Reserved1": )"; + builder << '"' << + writer.getReserved1AsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("QuoteEntryOpen": )"; + builder << '"' << writer.quoteEntryOpen() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoQuoteEntries": [)"; + writer.noQuoteEntries().forEach( + [&](NoQuoteEntries &noQuoteEntries) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noQuoteEntries; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noQuoteEntriesGroup { noQuoteEntries() }; + while (noQuoteEntriesGroup.hasNext()) + { + noQuoteEntriesGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noQuoteEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoQuoteEntries::sbeHeaderSize(); + if (noQuoteEntriesLength > 254LL) + { + throw std::runtime_error("noQuoteEntriesLength outside of allowed range [E110]"); + } + length += noQuoteEntriesLength *NoQuoteEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassQuoteAck545.h b/src/lib/orderman/ilink3/generated/MassQuoteAck545.h index c6da5e687..9f1d810b1 100644 --- a/src/lib/orderman/ilink3/generated/MassQuoteAck545.h +++ b/src/lib/orderman/ilink3/generated/MassQuoteAck545.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2602 +86,2946 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class MassQuoteAck545 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class MassQuoteAck545 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(351); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(545); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - MassQuoteAck545() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MassQuoteAck545( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - MassQuoteAck545(char *buffer, const std::uint64_t bufferLength) - : MassQuoteAck545( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MassQuoteAck545() = default; - MassQuoteAck545( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MassQuoteAck545( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MassQuoteAck545( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)350; - } + MassQuoteAck545(char *buffer, const std::uint64_t bufferLength) : + MassQuoteAck545(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + MassQuoteAck545( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MassQuoteAck545(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)545; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(351); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(545); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "b"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - MassQuoteAck545 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MassQuoteAck545( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "b"; + } - MassQuoteAck545 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + MassQuoteAck545 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MassQuoteAck545(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = MassQuoteAck545( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MassQuoteAck545 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - MassQuoteAck545 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = MassQuoteAck545( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = MassQuoteAck545( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + MassQuoteAck545 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = MassQuoteAck545(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MassQuoteAck545 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - MassQuoteAck545 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MassQuoteAck545 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MassQuoteAck545 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + MassQuoteAck545 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MassQuoteAck545 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + MassQuoteAck545 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } + static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT + { + return 58; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= textSinceVersion(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 256; + } - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 256; + } - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - MassQuoteAck545 &text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } + MassQuoteAck545 &text(const std::uint64_t index, const char value) + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } + std::uint64_t getText(char *const dst, const std::uint64_t length) const + { + if (length > 256) + { + throw std::runtime_error("length too large for getText [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - MassQuoteAck545 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } + MassQuoteAck545 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); + return *this; + } - SBE_NODISCARD std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); + std::string getTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTextAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - MassQuoteAck545 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + #if __cplusplus >= 201703L + MassQuoteAck545 &putText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - MassQuoteAck545 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + return *this; + } + #else + MassQuoteAck545 &putText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 268; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); + return (val); + } - MassQuoteAck545 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + MassQuoteAck545 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast(length)); + return length; + } - MassQuoteAck545 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 20); - return *this; - } + MassQuoteAck545 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - MassQuoteAck545 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + MassQuoteAck545 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#else - MassQuoteAck545 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + MassQuoteAck545 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 288; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 288; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 288, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 288, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MassQuoteAck545 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 288, &val, sizeof(std::uint64_t)); - return *this; - } + MassQuoteAck545 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 288, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - RequestTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimeId() SBE_NOEXCEPT { - return 5979; - } + static SBE_CONSTEXPR std::uint16_t requestTimeId() SBE_NOEXCEPT + { + return 5979; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimeSinceVersion(); + return m_actingVersion >= requestTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimeEncodingOffset() SBE_NOEXCEPT { - return 296; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimeEncodingOffset() SBE_NOEXCEPT + { + return 296; + } - static SBE_CONSTEXPR std::uint64_t requestTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 296, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 296, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MassQuoteAck545 &requestTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 296, &val, sizeof(std::uint64_t)); - return *this; - } + MassQuoteAck545 &requestTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 296, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 304; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 304; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 304, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 304, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MassQuoteAck545 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 304, &val, sizeof(std::uint64_t)); - return *this; - } + MassQuoteAck545 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 304, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteReqIDId() SBE_NOEXCEPT { - return 131; - } + static SBE_CONSTEXPR std::uint16_t quoteReqIDId() SBE_NOEXCEPT + { + return 131; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteReqIDSinceVersion(); + return m_actingVersion >= quoteReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteReqIDEncodingOffset() SBE_NOEXCEPT { - return 312; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteReqIDEncodingOffset() SBE_NOEXCEPT + { + return 312; + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t quoteReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 312, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t quoteReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 312, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MassQuoteAck545 "eReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 312, &val, sizeof(std::uint64_t)); - return *this; - } + MassQuoteAck545 "eReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 312, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 320; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 320; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 320; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 320; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 320; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 320; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 320 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 320 + (index * 1), sizeof(char)); + return (val); + } - MassQuoteAck545 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + MassQuoteAck545 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 320 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 320 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 320, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 320, sizeof(char) * static_cast(length)); + return length; + } - MassQuoteAck545 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 320, src, sizeof(char) * 5); - return *this; - } + MassQuoteAck545 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 320, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 320; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 320; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 320; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 320; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - MassQuoteAck545 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + MassQuoteAck545 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 320, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 320 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 320, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 320 + start] = 0; + } - return *this; - } -#else - MassQuoteAck545 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + MassQuoteAck545 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 320, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 320 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 320, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 320 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteIDId() SBE_NOEXCEPT { return 117; } + static SBE_CONSTEXPR std::uint16_t quoteIDId() SBE_NOEXCEPT + { + return 117; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteIDSinceVersion(); + return m_actingVersion >= quoteIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteIDEncodingOffset() SBE_NOEXCEPT { - return 325; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteIDEncodingOffset() SBE_NOEXCEPT + { + return 325; + } - static SBE_CONSTEXPR std::uint32_t quoteIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t quoteIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t quoteID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 325, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t quoteID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 325, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MassQuoteAck545 "eID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 325, &val, sizeof(std::uint32_t)); - return *this; - } + MassQuoteAck545 "eID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 325, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *QuoteRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonId() SBE_NOEXCEPT { - return 300; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonId() SBE_NOEXCEPT + { + return 300; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteRejectReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteRejectReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteRejectReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteRejectReasonSinceVersion(); + return m_actingVersion >= quoteRejectReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 329; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteRejectReasonEncodingOffset() SBE_NOEXCEPT + { + return 329; + } - static SBE_CONSTEXPR std::uint16_t - quoteRejectReasonNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - quoteRejectReasonEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t quoteRejectReasonEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t quoteRejectReason() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t quoteRejectReason() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MassQuoteAck545 "eRejectReason(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 329, &val, sizeof(std::uint16_t)); - return *this; - } + MassQuoteAck545 "eRejectReason(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 329, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 331; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 331; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 331, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 331, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MassQuoteAck545 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 331, &val, sizeof(std::uint16_t)); - return *this; - } + MassQuoteAck545 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 331, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - QuoteStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteStatusId() SBE_NOEXCEPT { - return 297; - } + static SBE_CONSTEXPR std::uint16_t quoteStatusId() SBE_NOEXCEPT + { + return 297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteStatusSinceVersion(); + return m_actingVersion >= quoteStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteStatusEncodingOffset() SBE_NOEXCEPT { - return 333; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteStatusEncodingOffset() SBE_NOEXCEPT + { + return 333; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD QuoteAckStatus::Value quoteStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint8_t)); - return QuoteAckStatus::get((val)); - } + SBE_NODISCARD std::uint8_t quoteStatusRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint8_t)); + return (val); + } - MassQuoteAck545 & - quoteStatus(const QuoteAckStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 333, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD QuoteAckStatus::Value quoteStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint8_t)); + return QuoteAckStatus::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + MassQuoteAck545 "eStatus(const QuoteAckStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 333, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 334; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 334; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 334, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 334, sizeof(std::uint8_t)); + return (val); + } - MassQuoteAck545 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 334, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 334, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *NoProcessedEntriesMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + MassQuoteAck545 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 334, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t noProcessedEntriesId() SBE_NOEXCEPT { - return 9772; - } + SBE_NODISCARD static const char *NoProcessedEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noProcessedEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t noProcessedEntriesId() SBE_NOEXCEPT + { + return 9772; + } - SBE_NODISCARD bool noProcessedEntriesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noProcessedEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noProcessedEntriesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noProcessedEntriesSinceVersion(); + return m_actingVersion >= noProcessedEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - noProcessedEntriesEncodingOffset() SBE_NOEXCEPT { - return 335; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t noProcessedEntriesEncodingOffset() SBE_NOEXCEPT + { + return 335; + } - static SBE_CONSTEXPR std::uint8_t - noProcessedEntriesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t noProcessedEntriesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t noProcessedEntriesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t noProcessedEntriesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t noProcessedEntriesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t noProcessedEntriesMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - noProcessedEntriesEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t noProcessedEntriesEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t noProcessedEntries() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 335, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t noProcessedEntries() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 335, sizeof(std::uint8_t)); + return (val); + } - MassQuoteAck545 &noProcessedEntries(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 335, &val, sizeof(std::uint8_t)); - return *this; - } + MassQuoteAck545 &noProcessedEntries(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 335, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *MMProtectionResetMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MMProtectionResetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mMProtectionResetId() SBE_NOEXCEPT { - return 9773; - } + static SBE_CONSTEXPR std::uint16_t mMProtectionResetId() SBE_NOEXCEPT + { + return 9773; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mMProtectionResetSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mMProtectionResetSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mMProtectionResetInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mMProtectionResetInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mMProtectionResetSinceVersion(); + return m_actingVersion >= mMProtectionResetSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mMProtectionResetEncodingOffset() SBE_NOEXCEPT { - return 336; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mMProtectionResetEncodingOffset() SBE_NOEXCEPT + { + return 336; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mMProtectionResetEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mMProtectionResetEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 336, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t mMProtectionResetRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 336, sizeof(std::uint8_t)); + return (val); + } - MassQuoteAck545 & - mMProtectionReset(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 336, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 336, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + MassQuoteAck545 &mMProtectionReset(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 336, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 337; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 337; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t)); + return (val); + } - MassQuoteAck545 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 337, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + MassQuoteAck545 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 337, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 338; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 338; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 338, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 338, sizeof(std::uint8_t)); + return (val); + } - MassQuoteAck545 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 338, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 338, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + MassQuoteAck545 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 338, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= shortSaleTypeSinceVersion(); + return m_actingVersion >= shortSaleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 339; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 339; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t)); + return (val); + } - MassQuoteAck545 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 339, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } - SBE_NODISCARD static const char *TotNoQuoteEntriesMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + MassQuoteAck545 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 339, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t totNoQuoteEntriesId() SBE_NOEXCEPT { - return 304; - } + SBE_NODISCARD static const char *TotNoQuoteEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNoQuoteEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t totNoQuoteEntriesId() SBE_NOEXCEPT + { + return 304; + } - SBE_NODISCARD bool totNoQuoteEntriesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNoQuoteEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool totNoQuoteEntriesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNoQuoteEntriesSinceVersion(); + return m_actingVersion >= totNoQuoteEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNoQuoteEntriesEncodingOffset() SBE_NOEXCEPT { - return 340; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingOffset() SBE_NOEXCEPT + { + return 340; + } - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t totNoQuoteEntries() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 340, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t totNoQuoteEntries() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 340, sizeof(std::uint8_t)); + return (val); + } - MassQuoteAck545 &totNoQuoteEntries(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 340, &val, sizeof(std::uint8_t)); - return *this; - } + MassQuoteAck545 &totNoQuoteEntries(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 340, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 2; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 341; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 341; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - if (m_actingVersion < 2) { - return BooleanFlag::NULL_VALUE; - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 2) + { + return static_cast(255); + } - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 341, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 341, sizeof(std::uint8_t)); + return (val); + } - MassQuoteAck545 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 341, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + if (m_actingVersion < 2) + { + return BooleanFlag::NULL_VALUE; + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 341, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + MassQuoteAck545 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 341, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 342; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 342; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return 0xffffffffffffffffL; - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return UINT64_C(0xffffffffffffffff); + } - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 342, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 342, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MassQuoteAck545 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 342, &val, sizeof(std::uint64_t)); - return *this; - } + MassQuoteAck545 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 342, &val, sizeof(std::uint64_t)); + return *this; + } - class NoQuoteEntries { + SBE_NODISCARD static const char *QuoteEntryOpenMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteEntryOpenId() SBE_NOEXCEPT + { + return 9182; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteEntryOpenSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool quoteEntryOpenInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= quoteEntryOpenSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryOpenEncodingOffset() SBE_NOEXCEPT + { + return 350; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryOpenEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t quoteEntryOpenRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 350, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value quoteEntryOpen() const + { + if (m_actingVersion < 8) + { + return BooleanNULL::NULL_VALUE; + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 350, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + MassQuoteAck545 "eEntryOpen(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 350, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoQuoteEntries + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)11); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 11; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 11; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoQuoteEntries &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *QuoteEntryIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t quoteEntryIDId() SBE_NOEXCEPT { - return 299; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteEntryIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteEntryIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteEntryIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteEntryIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t quoteEntryIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - quoteEntryIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t quoteEntryID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteEntries "eEntryID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { - return 48; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteEntries &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDId() SBE_NOEXCEPT { - return 302; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteSetIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteSetIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteSetIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteSetIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t quoteSetID() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoQuoteEntries "eSetID(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char *QuoteEntryRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - quoteEntryRejectReasonId() SBE_NOEXCEPT { - return 368; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteEntryRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteEntryRejectReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteEntryRejectReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteEntryRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 10; - } - - static SBE_CONSTEXPR std::uint8_t - quoteEntryRejectReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - quoteEntryRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - quoteEntryRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - quoteEntryRejectReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t quoteEntryRejectReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 10, sizeof(std::uint8_t)); - return (val); - } - - NoQuoteEntries & - quoteEntryRejectReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 10, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoQuoteEntries writer) { - builder << '{'; - builder << R"("QuoteEntryID": )"; - builder << +writer.quoteEntryID(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("QuoteSetID": )"; - builder << +writer.quoteSetID(); - - builder << ", "; - builder << R"("QuoteEntryRejectReason": )"; - builder << +writer.quoteEntryRejectReason(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoQuoteEntries m_noQuoteEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoQuoteEntriesId() SBE_NOEXCEPT { - return 295; - } - - SBE_NODISCARD inline NoQuoteEntries &noQuoteEntries() { - m_noQuoteEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } - - NoQuoteEntries &noQuoteEntriesCount(const std::uint8_t count) { - m_noQuoteEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noQuoteEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noQuoteEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noQuoteEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, MassQuoteAck545 _writer) { - MassQuoteAck545 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MassQuoteAck545", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); - - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("RequestTime": )"; - builder << +writer.requestTime(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("QuoteReqID": )"; - builder << +writer.quoteReqID(); - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("QuoteID": )"; - builder << +writer.quoteID(); - - builder << ", "; - builder << R"("QuoteRejectReason": )"; - builder << +writer.quoteRejectReason(); - - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); - - builder << ", "; - builder << R"("QuoteStatus": )"; - builder << '"' << writer.quoteStatus() << '"'; - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("NoProcessedEntries": )"; - builder << +writer.noProcessedEntries(); - - builder << ", "; - builder << R"("MMProtectionReset": )"; - builder << '"' << writer.mMProtectionReset() << '"'; - - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; - - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; - - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; - - builder << ", "; - builder << R"("TotNoQuoteEntries": )"; - builder << +writer.totNoQuoteEntries(); - - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; - - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoQuoteEntries": [)"; - writer.noQuoteEntries().forEach([&](NoQuoteEntries &noQuoteEntries) { - if (atLeastOne) { - builder << ", "; + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - atLeastOne = true; - builder << noQuoteEntries; - }); - builder << ']'; - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(11)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 11; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - return builder; - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 11; + } - void skip() { - noQuoteEntries().forEach([](NoQuoteEntries e) { e.skip(); }); - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t NoQuoteEntriesLength = 0) { + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoQuoteEntries &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *QuoteEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteEntryIDId() SBE_NOEXCEPT + { + return 299; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteEntryIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteEntryIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteEntryIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint32_t quoteEntryIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t quoteEntryID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries "eEntryID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= securityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDId() SBE_NOEXCEPT + { + return 302; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteSetIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteSetIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteSetIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteSetIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t quoteSetID() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoQuoteEntries "eSetID(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *QuoteEntryRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteEntryRejectReasonId() SBE_NOEXCEPT + { + return 368; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteEntryRejectReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteEntryRejectReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteEntryRejectReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryRejectReasonEncodingOffset() SBE_NOEXCEPT + { + return 10; + } + + static SBE_CONSTEXPR std::uint8_t quoteEntryRejectReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t quoteEntryRejectReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t quoteEntryRejectReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t quoteEntryRejectReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t quoteEntryRejectReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 10, sizeof(std::uint8_t)); + return (val); + } + + NoQuoteEntries "eEntryRejectReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 10, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoQuoteEntries writer) + { + builder << '{'; + builder << R"("QuoteEntryID": )"; + builder << +writer.quoteEntryID(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("QuoteSetID": )"; + builder << +writer.quoteSetID(); + + builder << ", "; + builder << R"("QuoteEntryRejectReason": )"; + builder << +writer.quoteEntryRejectReason(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoQuoteEntries::sbeHeaderSize(); - if (NoQuoteEntriesLength > 254) { - throw std::runtime_error( - "NoQuoteEntriesLength outside of allowed range [E110]"); - } - length += NoQuoteEntriesLength * NoQuoteEntries::sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } + } + }; + +private: + NoQuoteEntries m_noQuoteEntries; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoQuoteEntriesId() SBE_NOEXCEPT + { + return 295; + } + + SBE_NODISCARD inline NoQuoteEntries &noQuoteEntries() + { + m_noQuoteEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteEntries; + } + + NoQuoteEntries &noQuoteEntriesCount(const std::uint8_t count) + { + m_noQuoteEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteEntries; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noQuoteEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noQuoteEntriesInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noQuoteEntriesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, MassQuoteAck545 _writer) +{ + MassQuoteAck545 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "MassQuoteAck545", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("RequestTime": )"; + builder << +writer.requestTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("QuoteReqID": )"; + builder << +writer.quoteReqID(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("QuoteID": )"; + builder << +writer.quoteID(); + + builder << ", "; + builder << R"("QuoteRejectReason": )"; + builder << +writer.quoteRejectReason(); + + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); + + builder << ", "; + builder << R"("QuoteStatus": )"; + builder << '"' << writer.quoteStatus() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("NoProcessedEntries": )"; + builder << +writer.noProcessedEntries(); + + builder << ", "; + builder << R"("MMProtectionReset": )"; + builder << '"' << writer.mMProtectionReset() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("TotNoQuoteEntries": )"; + builder << +writer.totNoQuoteEntries(); + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); + + builder << ", "; + builder << R"("QuoteEntryOpen": )"; + builder << '"' << writer.quoteEntryOpen() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoQuoteEntries": [)"; + writer.noQuoteEntries().forEach( + [&](NoQuoteEntries &noQuoteEntries) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noQuoteEntries; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noQuoteEntriesGroup { noQuoteEntries() }; + while (noQuoteEntriesGroup.hasNext()) + { + noQuoteEntriesGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noQuoteEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoQuoteEntries::sbeHeaderSize(); + if (noQuoteEntriesLength > 254LL) + { + throw std::runtime_error("noQuoteEntriesLength outside of allowed range [E110]"); + } + length += noQuoteEntriesLength *NoQuoteEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassStatusOrdTyp.h b/src/lib/orderman/ilink3/generated/MassStatusOrdTyp.h index b441a7040..936dd01a0 100644 --- a/src/lib/orderman/ilink3/generated/MassStatusOrdTyp.h +++ b/src/lib/orderman/ilink3/generated/MassStatusOrdTyp.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MASSSTATUSORDTYP_H_ #define _ILINKBINARY_MASSSTATUSORDTYP_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,49 +25,48 @@ namespace iLinkBinary { -class MassStatusOrdTyp { - public: - enum Value { - SenderSubID = (std::uint8_t)100, - Account = (std::uint8_t)101, - NULL_VALUE = (std::uint8_t)255 - }; +class MassStatusOrdTyp +{ +public: + enum Value + { + SenderSubID = static_cast(100), + Account = static_cast(101), + NULL_VALUE = static_cast(255) + }; - static MassStatusOrdTyp::Value get(const std::uint8_t value) { - switch (value) { - case 100: - return SenderSubID; - case 101: - return Account; - case 255: - return NULL_VALUE; - } + static MassStatusOrdTyp::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(100): return SenderSubID; + case static_cast(101): return Account; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum MassStatusOrdTyp [E103]"); - } + throw std::runtime_error("unknown value for enum MassStatusOrdTyp [E103]"); + } - static const char *c_str(const MassStatusOrdTyp::Value value) { - switch (value) { - case SenderSubID: - return "SenderSubID"; - case Account: - return "Account"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MassStatusOrdTyp::Value value) + { + switch (value) + { + case SenderSubID: return "SenderSubID"; + case Account: return "Account"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum MassStatusOrdTyp [E103]:"); - } + throw std::runtime_error("unknown value for enum MassStatusOrdTyp [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, MassStatusOrdTyp::Value m) { - return os << MassStatusOrdTyp::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, MassStatusOrdTyp::Value m) + { + return os << MassStatusOrdTyp::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassStatusReqTyp.h b/src/lib/orderman/ilink3/generated/MassStatusReqTyp.h index 7428d1156..5ff457dd3 100644 --- a/src/lib/orderman/ilink3/generated/MassStatusReqTyp.h +++ b/src/lib/orderman/ilink3/generated/MassStatusReqTyp.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MASSSTATUSREQTYP_H_ #define _ILINKBINARY_MASSSTATUSREQTYP_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,54 +25,54 @@ namespace iLinkBinary { -class MassStatusReqTyp { - public: - enum Value { - Instrument = (std::uint8_t)1, - InstrumentGroup = (std::uint8_t)3, - MarketSegment = (std::uint8_t)100, - NULL_VALUE = (std::uint8_t)255 - }; +class MassStatusReqTyp +{ +public: + enum Value + { + Instrument = static_cast(1), + InstrumentGroup = static_cast(3), + AllOrders = static_cast(7), + MarketSegment = static_cast(100), + NULL_VALUE = static_cast(255) + }; - static MassStatusReqTyp::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return Instrument; - case 3: - return InstrumentGroup; - case 100: - return MarketSegment; - case 255: - return NULL_VALUE; - } + static MassStatusReqTyp::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return Instrument; + case static_cast(3): return InstrumentGroup; + case static_cast(7): return AllOrders; + case static_cast(100): return MarketSegment; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum MassStatusReqTyp [E103]"); - } + throw std::runtime_error("unknown value for enum MassStatusReqTyp [E103]"); + } - static const char *c_str(const MassStatusReqTyp::Value value) { - switch (value) { - case Instrument: - return "Instrument"; - case InstrumentGroup: - return "InstrumentGroup"; - case MarketSegment: - return "MarketSegment"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MassStatusReqTyp::Value value) + { + switch (value) + { + case Instrument: return "Instrument"; + case InstrumentGroup: return "InstrumentGroup"; + case AllOrders: return "AllOrders"; + case MarketSegment: return "MarketSegment"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum MassStatusReqTyp [E103]:"); - } + throw std::runtime_error("unknown value for enum MassStatusReqTyp [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, MassStatusReqTyp::Value m) { - return os << MassStatusReqTyp::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, MassStatusReqTyp::Value m) + { + return os << MassStatusReqTyp::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MassStatusTIF.h b/src/lib/orderman/ilink3/generated/MassStatusTIF.h index ddfbd4dab..6de553669 100644 --- a/src/lib/orderman/ilink3/generated/MassStatusTIF.h +++ b/src/lib/orderman/ilink3/generated/MassStatusTIF.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_MASSSTATUSTIF_H_ #define _ILINKBINARY_MASSSTATUSTIF_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,52 +25,54 @@ namespace iLinkBinary { -class MassStatusTIF { - public: - enum Value { - Day = (std::uint8_t)0, - GTC = (std::uint8_t)1, - GTD = (std::uint8_t)6, - NULL_VALUE = (std::uint8_t)255 - }; +class MassStatusTIF +{ +public: + enum Value + { + Day = static_cast(0), + GTC = static_cast(1), + GTD = static_cast(6), + GFS = static_cast(99), + NULL_VALUE = static_cast(255) + }; - static MassStatusTIF::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Day; - case 1: - return GTC; - case 6: - return GTD; - case 255: - return NULL_VALUE; - } + static MassStatusTIF::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Day; + case static_cast(1): return GTC; + case static_cast(6): return GTD; + case static_cast(99): return GFS; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum MassStatusTIF [E103]"); - } + throw std::runtime_error("unknown value for enum MassStatusTIF [E103]"); + } - static const char *c_str(const MassStatusTIF::Value value) { - switch (value) { - case Day: - return "Day"; - case GTC: - return "GTC"; - case GTD: - return "GTD"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MassStatusTIF::Value value) + { + switch (value) + { + case Day: return "Day"; + case GTC: return "GTC"; + case GTD: return "GTD"; + case GFS: return "GFS"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum MassStatusTIF [E103]:"); - } + throw std::runtime_error("unknown value for enum MassStatusTIF [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, MassStatusTIF::Value m) { - return os << MassStatusTIF::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, MassStatusTIF::Value m) + { + return os << MassStatusTIF::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MaturityMonthYear.h b/src/lib/orderman/ilink3/generated/MaturityMonthYear.h index 43cc70e96..1b5875d8d 100644 --- a/src/lib/orderman/ilink3/generated/MaturityMonthYear.h +++ b/src/lib/orderman/ilink3/generated/MaturityMonthYear.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,357 +86,424 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace iLinkBinary { -class MaturityMonthYear { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class MaturityMonthYear +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MaturityMonthYear() = default; + MaturityMonthYear() = default; - MaturityMonthYear( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_actingVersion(actingVersion) { - if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 5) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + MaturityMonthYear( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_actingVersion(actingVersion) + { + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 5) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - MaturityMonthYear( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : MaturityMonthYear(buffer, 0, bufferLength, actingVersion) {} + MaturityMonthYear( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + MaturityMonthYear(buffer, 0, bufferLength, actingVersion) + { + } - MaturityMonthYear(char *buffer, const std::uint64_t bufferLength) - : MaturityMonthYear(buffer, 0, bufferLength, sbeSchemaVersion()) {} + MaturityMonthYear( + char *buffer, + const std::uint64_t bufferLength) : + MaturityMonthYear(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - MaturityMonthYear &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = - MaturityMonthYear(buffer, offset, bufferLength, actingVersion); - } + MaturityMonthYear &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = MaturityMonthYear(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static const char * - yearMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *yearMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t yearId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t yearId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - yearSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t yearSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool yearInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool yearInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= yearSinceVersion(); + return m_actingVersion >= yearSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - yearEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t yearEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t yearNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t yearNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t yearMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t yearMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t yearMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t yearMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t yearEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t yearEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t year() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t year() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MaturityMonthYear &year(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); - return *this; - } + MaturityMonthYear &year(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - monthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *monthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t monthId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t monthId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - monthSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t monthSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool monthInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool monthInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= monthSinceVersion(); + return m_actingVersion >= monthSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - monthEncodingOffset() SBE_NOEXCEPT { - return 2; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t monthEncodingOffset() SBE_NOEXCEPT + { + return 2; + } - static SBE_CONSTEXPR std::uint8_t monthNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t monthNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t monthMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t monthMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t monthMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t monthMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t monthEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t monthEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t month() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t month() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint8_t)); + return (val); + } - MaturityMonthYear &month(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint8_t)); - return *this; - } + MaturityMonthYear &month(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - dayMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *dayMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t dayId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t dayId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - daySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t daySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool dayInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool dayInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= daySinceVersion(); + return m_actingVersion >= daySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - dayEncodingOffset() SBE_NOEXCEPT { - return 3; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t dayEncodingOffset() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint8_t dayNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t dayNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t dayMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t dayMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t dayMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t dayMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t dayEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t dayEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t day() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t day() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::uint8_t)); + return (val); + } - MaturityMonthYear &day(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::uint8_t)); - return *this; - } + MaturityMonthYear &day(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - weekMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *weekMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t weekId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t weekId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - weekSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t weekSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool weekInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool weekInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= weekSinceVersion(); + return m_actingVersion >= weekSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - weekEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t weekEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint8_t weekNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t weekNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t weekMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t weekMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t weekMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t weekMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t weekEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t weekEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t week() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t week() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint8_t)); + return (val); + } - MaturityMonthYear &week(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint8_t)); - return *this; - } + MaturityMonthYear &week(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint8_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, MaturityMonthYear writer) { - builder << '{'; - builder << R"("year": )"; - builder << +writer.year(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, MaturityMonthYear writer) +{ + builder << '{'; + builder << R"("year": )"; + builder << +writer.year(); - builder << ", "; - builder << R"("month": )"; - builder << +writer.month(); + builder << ", "; + builder << R"("month": )"; + builder << +writer.month(); - builder << ", "; - builder << R"("day": )"; - builder << +writer.day(); + builder << ", "; + builder << R"("day": )"; + builder << +writer.day(); - builder << ", "; - builder << R"("week": )"; - builder << +writer.week(); + builder << ", "; + builder << R"("week": )"; + builder << +writer.week(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/MessageHeader.h b/src/lib/orderman/ilink3/generated/MessageHeader.h index e4234dfd4..0fa76d344 100644 --- a/src/lib/orderman/ilink3/generated/MessageHeader.h +++ b/src/lib/orderman/ilink3/generated/MessageHeader.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,358 +86,424 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace iLinkBinary { -class MessageHeader { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class MessageHeader +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MessageHeader() = default; + MessageHeader() = default; - MessageHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_actingVersion(actingVersion) { - if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 8) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + MessageHeader( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_actingVersion(actingVersion) + { + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 8) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - MessageHeader( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : MessageHeader(buffer, 0, bufferLength, actingVersion) {} + MessageHeader( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + MessageHeader(buffer, 0, bufferLength, actingVersion) + { + } - MessageHeader(char *buffer, const std::uint64_t bufferLength) - : MessageHeader(buffer, 0, bufferLength, sbeSchemaVersion()) {} + MessageHeader( + char *buffer, + const std::uint64_t bufferLength) : + MessageHeader(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - MessageHeader &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = MessageHeader(buffer, offset, bufferLength, actingVersion); - } + MessageHeader &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = MessageHeader(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static const char * - blockLengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *blockLengthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t blockLengthId() SBE_NOEXCEPT { - return -1; - } + static SBE_CONSTEXPR std::uint16_t blockLengthId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - blockLengthSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t blockLengthSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool blockLengthInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool blockLengthInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= blockLengthSinceVersion(); + return m_actingVersion >= blockLengthSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - blockLengthEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t blockLengthEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t blockLengthNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t blockLengthNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t blockLengthMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t blockLengthMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t blockLengthMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t blockLengthMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t blockLengthEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t blockLengthEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t blockLength() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t blockLength() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MessageHeader &blockLength(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); - return *this; - } + MessageHeader &blockLength(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - templateIdMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *templateIdMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t templateIdId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t templateIdId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - templateIdSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t templateIdSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool templateIdInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool templateIdInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= templateIdSinceVersion(); + return m_actingVersion >= templateIdSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - templateIdEncodingOffset() SBE_NOEXCEPT { - return 2; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t templateIdEncodingOffset() SBE_NOEXCEPT + { + return 2; + } - static SBE_CONSTEXPR std::uint16_t templateIdNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t templateIdNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t templateIdMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t templateIdMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t templateIdMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t templateIdMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t templateIdEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t templateIdEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t templateId() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t templateId() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MessageHeader &templateId(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint16_t)); - return *this; - } + MessageHeader &templateId(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - schemaIdMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *schemaIdMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t schemaIdId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t schemaIdId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - schemaIdSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t schemaIdSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool schemaIdInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool schemaIdInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= schemaIdSinceVersion(); + return m_actingVersion >= schemaIdSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - schemaIdEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t schemaIdEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint16_t schemaIdNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t schemaIdNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t schemaIdMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t schemaIdMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t schemaIdMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t schemaIdMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t schemaIdEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t schemaIdEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t schemaId() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t schemaId() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MessageHeader &schemaId(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint16_t)); - return *this; - } + MessageHeader &schemaId(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - versionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *versionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t versionId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t versionId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - versionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t versionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool versionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool versionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= versionSinceVersion(); + return m_actingVersion >= versionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - versionEncodingOffset() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t versionEncodingOffset() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint16_t versionNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t versionNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t versionMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t versionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t versionMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t versionMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t versionEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t versionEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t version() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t version() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MessageHeader &version(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint16_t)); - return *this; - } + MessageHeader &version(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint16_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, MessageHeader writer) { - builder << '{'; - builder << R"("blockLength": )"; - builder << +writer.blockLength(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, MessageHeader writer) +{ + builder << '{'; + builder << R"("blockLength": )"; + builder << +writer.blockLength(); - builder << ", "; - builder << R"("templateId": )"; - builder << +writer.templateId(); + builder << ", "; + builder << R"("templateId": )"; + builder << +writer.templateId(); - builder << ", "; - builder << R"("schemaId": )"; - builder << +writer.schemaId(); + builder << ", "; + builder << R"("schemaId": )"; + builder << +writer.schemaId(); - builder << ", "; - builder << R"("version": )"; - builder << +writer.version(); + builder << ", "; + builder << R"("version": )"; + builder << +writer.version(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/Negotiate500.h b/src/lib/orderman/ilink3/generated/Negotiate500.h index 67a081661..8f7e3488b 100644 --- a/src/lib/orderman/ilink3/generated/Negotiate500.h +++ b/src/lib/orderman/ilink3/generated/Negotiate500.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1655 +86,1763 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class Negotiate500 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class Negotiate500 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(76); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(500); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - Negotiate500() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - Negotiate500( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - Negotiate500(char *buffer, const std::uint64_t bufferLength) - : Negotiate500( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + Negotiate500() = default; - Negotiate500( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : Negotiate500( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + Negotiate500( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)76; - } + Negotiate500(char *buffer, const std::uint64_t bufferLength) : + Negotiate500(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + Negotiate500( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + Negotiate500(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)500; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(76); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(500); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "Negotiate"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - Negotiate500 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = Negotiate500( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "Negotiate"; + } - Negotiate500 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + Negotiate500 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = Negotiate500(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = Negotiate500( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + Negotiate500 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - Negotiate500 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = Negotiate500( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = Negotiate500( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + Negotiate500 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = Negotiate500(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + Negotiate500 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - Negotiate500 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + Negotiate500 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - CustomerFlowMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t customerFlowId() SBE_NOEXCEPT { - return 39000; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - customerFlowSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool customerFlowInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *CustomerFlowMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t customerFlowId() SBE_NOEXCEPT + { + return 39000; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t customerFlowSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool customerFlowInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= customerFlowSinceVersion(); + return m_actingVersion >= customerFlowSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - customerFlowEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t customerFlowEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char customerFlowNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char customerFlowNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char customerFlowMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char customerFlowMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char customerFlowMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char customerFlowMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t customerFlowEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t customerFlowEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t customerFlowLength() SBE_NOEXCEPT { - return 10; - } + static SBE_CONSTEXPR std::uint64_t customerFlowLength() SBE_NOEXCEPT + { + return 10; + } - SBE_NODISCARD const char *customerFlow() const { - static const std::uint8_t customerFlowValues[] = {73, 68, 69, 77, 80, - 79, 84, 69, 78, 84}; + SBE_NODISCARD const char *customerFlow() const + { + static const std::uint8_t customerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84, 0 }; - return (const char *)customerFlowValues; - } + return (const char *)customerFlowValues; + } - SBE_NODISCARD char customerFlow(const std::uint64_t index) const { - static const std::uint8_t customerFlowValues[] = {73, 68, 69, 77, 80, - 79, 84, 69, 78, 84}; + SBE_NODISCARD char customerFlow(const std::uint64_t index) const + { + static const std::uint8_t customerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84, 0 }; - return (char)customerFlowValues[index]; - } + return (char)customerFlowValues[index]; + } - std::uint64_t getCustomerFlow(char *dst, const std::uint64_t length) const { - static std::uint8_t customerFlowValues[] = {73, 68, 69, 77, 80, - 79, 84, 69, 78, 84}; - std::uint64_t bytesToCopy = length < sizeof(customerFlowValues) - ? length - : sizeof(customerFlowValues); + std::uint64_t getCustomerFlow(char *dst, const std::uint64_t length) const + { + static std::uint8_t customerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84 }; + std::uint64_t bytesToCopy = length < sizeof(customerFlowValues) ? length : sizeof(customerFlowValues); - std::memcpy(dst, customerFlowValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, customerFlowValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getCustomerFlowAsString() const { - static const std::uint8_t CustomerFlowValues[] = {73, 68, 69, 77, 80, - 79, 84, 69, 78, 84}; + std::string getCustomerFlowAsString() const + { + static const std::uint8_t CustomerFlowValues[] = { 73, 68, 69, 77, 80, 79, 84, 69, 78, 84 }; - return std::string((const char *)CustomerFlowValues, 10); - } + return std::string((const char *)CustomerFlowValues, 10); + } - std::string getCustomerFlowAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCustomerFlowAsString(); + std::string getCustomerFlowAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCustomerFlowAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - HMACVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HMACVersionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t hMACVersionId() SBE_NOEXCEPT { - return 39003; - } + static SBE_CONSTEXPR std::uint16_t hMACVersionId() SBE_NOEXCEPT + { + return 39003; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hMACVersionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hMACVersionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool hMACVersionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool hMACVersionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hMACVersionSinceVersion(); + return m_actingVersion >= hMACVersionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hMACVersionEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hMACVersionEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char hMACVersionNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char hMACVersionMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char hMACVersionMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t hMACVersionEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t hMACVersionLength() SBE_NOEXCEPT { - return 13; - } + static SBE_CONSTEXPR std::uint64_t hMACVersionLength() SBE_NOEXCEPT + { + return 13; + } - SBE_NODISCARD const char *hMACVersion() const { - static const std::uint8_t hMACVersionValues[] = { - 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54}; + SBE_NODISCARD const char *hMACVersion() const + { + static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54, 0 }; - return (const char *)hMACVersionValues; - } + return (const char *)hMACVersionValues; + } - SBE_NODISCARD char hMACVersion(const std::uint64_t index) const { - static const std::uint8_t hMACVersionValues[] = { - 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54}; + SBE_NODISCARD char hMACVersion(const std::uint64_t index) const + { + static const std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54, 0 }; - return (char)hMACVersionValues[index]; - } + return (char)hMACVersionValues[index]; + } - std::uint64_t getHMACVersion(char *dst, const std::uint64_t length) const { - static std::uint8_t hMACVersionValues[] = {67, 77, 69, 45, 49, 45, 83, - 72, 65, 45, 50, 53, 54}; - std::uint64_t bytesToCopy = length < sizeof(hMACVersionValues) - ? length - : sizeof(hMACVersionValues); + std::uint64_t getHMACVersion(char *dst, const std::uint64_t length) const + { + static std::uint8_t hMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 }; + std::uint64_t bytesToCopy = length < sizeof(hMACVersionValues) ? length : sizeof(hMACVersionValues); - std::memcpy(dst, hMACVersionValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, hMACVersionValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getHMACVersionAsString() const { - static const std::uint8_t HMACVersionValues[] = { - 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54}; + std::string getHMACVersionAsString() const + { + static const std::uint8_t HMACVersionValues[] = { 67, 77, 69, 45, 49, 45, 83, 72, 65, 45, 50, 53, 54 }; - return std::string((const char *)HMACVersionValues, 13); - } + return std::string((const char *)HMACVersionValues, 13); + } - std::string getHMACVersionAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getHMACVersionAsString(); + std::string getHMACVersionAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getHMACVersionAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - HMACSignatureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HMACSignatureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t hMACSignatureId() SBE_NOEXCEPT { - return 39005; - } + static SBE_CONSTEXPR std::uint16_t hMACSignatureId() SBE_NOEXCEPT + { + return 39005; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - hMACSignatureSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t hMACSignatureSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool hMACSignatureInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool hMACSignatureInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= hMACSignatureSinceVersion(); + return m_actingVersion >= hMACSignatureSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - hMACSignatureEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t hMACSignatureEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char hMACSignatureNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char hMACSignatureMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char hMACSignatureMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT { - return 32; - } + static SBE_CONSTEXPR std::size_t hMACSignatureEncodingLength() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR std::uint64_t hMACSignatureLength() SBE_NOEXCEPT { - return 32; - } + static SBE_CONSTEXPR std::uint64_t hMACSignatureLength() SBE_NOEXCEPT + { + return 32; + } - SBE_NODISCARD const char *hMACSignature() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } + SBE_NODISCARD const char *hMACSignature() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char *hMACSignature() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } + SBE_NODISCARD char *hMACSignature() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char hMACSignature(const std::uint64_t index) const { - if (index >= 32) { - throw std::runtime_error( - "index out of range for hMACSignature [E104]"); - } + SBE_NODISCARD char hMACSignature(const std::uint64_t index) const + { + if (index >= 32) + { + throw std::runtime_error("index out of range for hMACSignature [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - Negotiate500 &hMACSignature(const std::uint64_t index, const char value) { - if (index >= 32) { - throw std::runtime_error( - "index out of range for hMACSignature [E105]"); - } + Negotiate500 &hMACSignature(const std::uint64_t index, const char value) + { + if (index >= 32) + { + throw std::runtime_error("index out of range for hMACSignature [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getHMACSignature(char *const dst, const std::uint64_t length) const { - if (length > 32) { - throw std::runtime_error( - "length too large for getHMACSignature [E106]"); - } + std::uint64_t getHMACSignature(char *const dst, const std::uint64_t length) const + { + if (length > 32) + { + throw std::runtime_error("length too large for getHMACSignature [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - Negotiate500 &putHMACSignature(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 32); - return *this; - } + Negotiate500 &putHMACSignature(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 32); + return *this; + } - SBE_NODISCARD std::string getHMACSignatureAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + SBE_NODISCARD std::string getHMACSignatureAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 32 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 32 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getHMACSignatureAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getHMACSignatureAsString(); + std::string getHMACSignatureAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getHMACSignatureAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getHMACSignatureAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getHMACSignatureAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 32 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 32 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Negotiate500 &putHMACSignature(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 32) { - throw std::runtime_error( - "string too large for putHMACSignature [E106]"); - } + #if __cplusplus >= 201703L + Negotiate500 &putHMACSignature(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 32) + { + throw std::runtime_error("string too large for putHMACSignature [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 32; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 32; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#else - Negotiate500 &putHMACSignature(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 32) { - throw std::runtime_error( - "string too large for putHMACSignature [E106]"); - } + return *this; + } + #else + Negotiate500 &putHMACSignature(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 32) + { + throw std::runtime_error("string too large for putHMACSignature [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 32; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 32; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AccessKeyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *AccessKeyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t accessKeyIDId() SBE_NOEXCEPT { - return 39004; - } + static SBE_CONSTEXPR std::uint16_t accessKeyIDId() SBE_NOEXCEPT + { + return 39004; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - accessKeyIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t accessKeyIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool accessKeyIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool accessKeyIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= accessKeyIDSinceVersion(); + return m_actingVersion >= accessKeyIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - accessKeyIDEncodingOffset() SBE_NOEXCEPT { - return 32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t accessKeyIDEncodingOffset() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char accessKeyIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char accessKeyIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char accessKeyIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t accessKeyIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t accessKeyIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t accessKeyIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *accessKeyID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 32; - } + SBE_NODISCARD const char *accessKeyID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 32; + } - SBE_NODISCARD char *accessKeyID() SBE_NOEXCEPT { - return m_buffer + m_offset + 32; - } + SBE_NODISCARD char *accessKeyID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 32; + } - SBE_NODISCARD char accessKeyID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for accessKeyID [E104]"); - } + SBE_NODISCARD char accessKeyID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for accessKeyID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 32 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 32 + (index * 1), sizeof(char)); + return (val); + } - Negotiate500 &accessKeyID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for accessKeyID [E105]"); - } + Negotiate500 &accessKeyID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for accessKeyID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 32 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 32 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getAccessKeyID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getAccessKeyID [E106]"); - } + std::uint64_t getAccessKeyID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getAccessKeyID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 32, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 32, sizeof(char) * static_cast(length)); + return length; + } - Negotiate500 &putAccessKeyID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 32, src, sizeof(char) * 20); - return *this; - } + Negotiate500 &putAccessKeyID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 32, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getAccessKeyIDAsString() const { - const char *buffer = m_buffer + m_offset + 32; - size_t length = 0; + SBE_NODISCARD std::string getAccessKeyIDAsString() const + { + const char *buffer = m_buffer + m_offset + 32; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getAccessKeyIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAccessKeyIDAsString(); + std::string getAccessKeyIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAccessKeyIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getAccessKeyIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 32; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAccessKeyIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 32; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Negotiate500 &putAccessKeyID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putAccessKeyID [E106]"); - } + #if __cplusplus >= 201703L + Negotiate500 &putAccessKeyID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAccessKeyID [E106]"); + } - std::memcpy(m_buffer + m_offset + 32, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 32 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 32, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 32 + start] = 0; + } - return *this; - } -#else - Negotiate500 &putAccessKeyID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putAccessKeyID [E106]"); - } + return *this; + } + #else + Negotiate500 &putAccessKeyID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAccessKeyID [E106]"); + } - std::memcpy(m_buffer + m_offset + 32, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 32 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 32, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 32 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 52; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 52; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 52, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 52, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Negotiate500 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 52, &val, sizeof(std::uint64_t)); - return *this; - } + Negotiate500 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 52, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 60; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Negotiate500 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 60, &val, sizeof(std::uint64_t)); - return *this; - } + Negotiate500 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 60, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - SessionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SessionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sessionId() SBE_NOEXCEPT { return 39006; } + static SBE_CONSTEXPR std::uint16_t sessionId() SBE_NOEXCEPT + { + return 39006; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sessionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sessionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sessionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sessionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sessionSinceVersion(); + return m_actingVersion >= sessionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sessionEncodingOffset() SBE_NOEXCEPT { - return 68; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sessionEncodingOffset() SBE_NOEXCEPT + { + return 68; + } - static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char sessionNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char sessionMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char sessionMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::size_t sessionEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t sessionLength() SBE_NOEXCEPT { return 3; } + static SBE_CONSTEXPR std::uint64_t sessionLength() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD const char *session() const SBE_NOEXCEPT { - return m_buffer + m_offset + 68; - } + SBE_NODISCARD const char *session() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 68; + } - SBE_NODISCARD char *session() SBE_NOEXCEPT { - return m_buffer + m_offset + 68; - } + SBE_NODISCARD char *session() SBE_NOEXCEPT + { + return m_buffer + m_offset + 68; + } - SBE_NODISCARD char session(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error("index out of range for session [E104]"); - } + SBE_NODISCARD char session(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for session [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 68 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 68 + (index * 1), sizeof(char)); + return (val); + } - Negotiate500 &session(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error("index out of range for session [E105]"); - } + Negotiate500 &session(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for session [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 68 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 68 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getSession(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error("length too large for getSession [E106]"); - } + std::uint64_t getSession(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getSession [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 68, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 68, sizeof(char) * static_cast(length)); + return length; + } - Negotiate500 &putSession(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 68, src, sizeof(char) * 3); - return *this; - } + Negotiate500 &putSession(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 68, src, sizeof(char) * 3); + return *this; + } - Negotiate500 &putSession( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 68, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 69, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 70, &val2, sizeof(char)); + Negotiate500 &putSession( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 68, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 69, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 70, &val2, sizeof(char)); - return *this; - } + return *this; + } - SBE_NODISCARD std::string getSessionAsString() const { - const char *buffer = m_buffer + m_offset + 68; - size_t length = 0; + SBE_NODISCARD std::string getSessionAsString() const + { + const char *buffer = m_buffer + m_offset + 68; + std::size_t length = 0; - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSessionAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSessionAsString(); + std::string getSessionAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSessionAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 68; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSessionAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 68; + std::size_t length = 0; - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Negotiate500 &putSession(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putSession [E106]"); - } + #if __cplusplus >= 201703L + Negotiate500 &putSession(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSession [E106]"); + } - std::memcpy(m_buffer + m_offset + 68, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 68 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 68, str.data(), srcLength); + for (std::size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 68 + start] = 0; + } - return *this; - } -#else - Negotiate500 &putSession(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putSession [E106]"); - } + return *this; + } + #else + Negotiate500 &putSession(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSession [E106]"); + } - std::memcpy(m_buffer + m_offset + 68, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 68 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 68, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 68 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - FirmMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FirmMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t firmId() SBE_NOEXCEPT { return 39007; } + static SBE_CONSTEXPR std::uint16_t firmId() SBE_NOEXCEPT + { + return 39007; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - firmSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t firmSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool firmInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool firmInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= firmSinceVersion(); + return m_actingVersion >= firmSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - firmEncodingOffset() SBE_NOEXCEPT { - return 71; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t firmEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char firmNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char firmMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char firmMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t firmEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t firmLength() SBE_NOEXCEPT { return 5; } + static SBE_CONSTEXPR std::uint64_t firmLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *firm() const SBE_NOEXCEPT { - return m_buffer + m_offset + 71; - } + SBE_NODISCARD const char *firm() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 71; + } - SBE_NODISCARD char *firm() SBE_NOEXCEPT { return m_buffer + m_offset + 71; } + SBE_NODISCARD char *firm() SBE_NOEXCEPT + { + return m_buffer + m_offset + 71; + } - SBE_NODISCARD char firm(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for firm [E104]"); - } + SBE_NODISCARD char firm(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for firm [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 71 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 71 + (index * 1), sizeof(char)); + return (val); + } - Negotiate500 &firm(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for firm [E105]"); - } + Negotiate500 &firm(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for firm [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 71 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 71 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getFirm(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getFirm [E106]"); - } + std::uint64_t getFirm(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getFirm [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 71, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 71, sizeof(char) * static_cast(length)); + return length; + } - Negotiate500 &putFirm(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 71, src, sizeof(char) * 5); - return *this; - } + Negotiate500 &putFirm(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 71, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getFirmAsString() const { - const char *buffer = m_buffer + m_offset + 71; - size_t length = 0; + SBE_NODISCARD std::string getFirmAsString() const + { + const char *buffer = m_buffer + m_offset + 71; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getFirmAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getFirmAsString(); + std::string getFirmAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getFirmAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 71; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getFirmAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 71; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Negotiate500 &putFirm(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putFirm [E106]"); - } + #if __cplusplus >= 201703L + Negotiate500 &putFirm(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putFirm [E106]"); + } - std::memcpy(m_buffer + m_offset + 71, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 71 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 71, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 71 + start] = 0; + } - return *this; - } -#else - Negotiate500 &putFirm(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putFirm [E106]"); - } + return *this; + } + #else + Negotiate500 &putFirm(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putFirm [E106]"); + } - std::memcpy(m_buffer + m_offset + 71, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 71 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 71, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 71 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "data"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "data"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static const char *credentialsCharacterEncoding() SBE_NOEXCEPT { - return "US-ASCII"; - } + static const char *credentialsCharacterEncoding() SBE_NOEXCEPT + { + return "US-ASCII"; + } - static SBE_CONSTEXPR std::uint64_t credentialsSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t credentialsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - bool credentialsInActingVersion() SBE_NOEXCEPT { + bool credentialsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= credentialsSinceVersion(); + return m_actingVersion >= credentialsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - static SBE_CONSTEXPR std::uint16_t credentialsId() SBE_NOEXCEPT { - return 39008; - } + static SBE_CONSTEXPR std::uint16_t credentialsId() SBE_NOEXCEPT + { + return 39008; + } - static SBE_CONSTEXPR std::uint64_t credentialsHeaderLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t credentialsHeaderLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t credentialsLength() const { - std::uint16_t length; - std::memcpy(&length, m_buffer + sbePosition(), sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(length); - } + SBE_NODISCARD std::uint16_t credentialsLength() const + { + std::uint16_t length; + std::memcpy(&length, m_buffer + sbePosition(), sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(length); + } - std::uint64_t skipCredentials() { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - sbePosition(lengthPosition + lengthOfLengthField + dataLength); - return dataLength; - } + std::uint64_t skipCredentials() + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + sbePosition(lengthPosition + lengthOfLengthField + dataLength); + return dataLength; + } - SBE_NODISCARD const char *credentials() { - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + sbePosition(), sizeof(std::uint16_t)); - const char *fieldPtr = m_buffer + sbePosition() + 2; - sbePosition( - sbePosition() + 2 + SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue)); - return fieldPtr; - } + SBE_NODISCARD const char *credentials() + { + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + sbePosition(), sizeof(std::uint16_t)); + const char *fieldPtr = m_buffer + sbePosition() + 2; + sbePosition(sbePosition() + 2 + SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue)); + return fieldPtr; + } - std::uint64_t getCredentials(char *dst, const std::uint64_t length) { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - sbePosition(lengthPosition + lengthOfLengthField); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - std::uint64_t bytesToCopy = length < dataLength ? length : dataLength; - std::uint64_t pos = sbePosition(); - sbePosition(pos + dataLength); - std::memcpy(dst, m_buffer + pos, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::uint64_t getCredentials(char *dst, const std::uint64_t length) + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + sbePosition(lengthPosition + lengthOfLengthField); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + std::uint64_t bytesToCopy = length < dataLength ? length : dataLength; + std::uint64_t pos = sbePosition(); + sbePosition(pos + dataLength); + std::memcpy(dst, m_buffer + pos, static_cast(bytesToCopy)); + return bytesToCopy; + } - Negotiate500 &putCredentials(const char *src, const std::uint16_t length) { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - std::uint16_t lengthFieldValue = SBE_LITTLE_ENDIAN_ENCODE_16(length); - sbePosition(lengthPosition + lengthOfLengthField); - std::memcpy( - m_buffer + lengthPosition, &lengthFieldValue, sizeof(std::uint16_t)); - if (length != std::uint16_t(0)) { - std::uint64_t pos = sbePosition(); - sbePosition(pos + length); - std::memcpy(m_buffer + pos, src, length); - } - return *this; - } + Negotiate500 &putCredentials(const char *src, const std::uint16_t length) + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + std::uint16_t lengthFieldValue = SBE_LITTLE_ENDIAN_ENCODE_16(length); + sbePosition(lengthPosition + lengthOfLengthField); + std::memcpy(m_buffer + lengthPosition, &lengthFieldValue, sizeof(std::uint16_t)); + if (length != std::uint16_t(0)) + { + std::uint64_t pos = sbePosition(); + sbePosition(pos + length); + std::memcpy(m_buffer + pos, src, length); + } + return *this; + } - std::string getCredentialsAsString() { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - sbePosition(lengthPosition + lengthOfLengthField); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - std::uint64_t pos = sbePosition(); - const std::string result(m_buffer + pos, dataLength); - sbePosition(pos + dataLength); - return result; - } + std::string getCredentialsAsString() + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + sbePosition(lengthPosition + lengthOfLengthField); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + std::uint64_t pos = sbePosition(); + const std::string result(m_buffer + pos, dataLength); + sbePosition(pos + dataLength); + return result; + } - std::string getCredentialsAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCredentialsAsString(); + std::string getCredentialsAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCredentialsAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - std::string_view getCredentialsAsStringView() { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - sbePosition(lengthPosition + lengthOfLengthField); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - std::uint64_t pos = sbePosition(); - const std::string_view result(m_buffer + pos, dataLength); - sbePosition(pos + dataLength); - return result; - } -#endif + #if __cplusplus >= 201703L + std::string_view getCredentialsAsStringView() + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + sbePosition(lengthPosition + lengthOfLengthField); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + std::uint64_t pos = sbePosition(); + const std::string_view result(m_buffer + pos, dataLength); + sbePosition(pos + dataLength); + return result; + } + #endif - Negotiate500 &putCredentials(const std::string &str) { - if (str.length() > 65534) { - throw std::runtime_error( - "std::string too long for length type [E109]"); - } - return putCredentials( - str.data(), static_cast(str.length())); - } + Negotiate500 &putCredentials(const std::string &str) + { + if (str.length() > 65534) + { + throw std::runtime_error("std::string too long for length type [E109]"); + } + return putCredentials(str.data(), static_cast(str.length())); + } -#if __cplusplus >= 201703L - Negotiate500 &putCredentials(const std::string_view str) { - if (str.length() > 65534) { - throw std::runtime_error( - "std::string too long for length type [E109]"); - } - return putCredentials( - str.data(), static_cast(str.length())); - } -#endif + #if __cplusplus >= 201703L + Negotiate500 &putCredentials(const std::string_view str) + { + if (str.length() > 65534) + { + throw std::runtime_error("std::string too long for length type [E109]"); + } + return putCredentials(str.data(), static_cast(str.length())); + } + #endif - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, Negotiate500 _writer) { - Negotiate500 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "Negotiate500", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, Negotiate500 _writer) +{ + Negotiate500 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("HMACSignature": )"; - builder << '"' << writer.getHMACSignatureAsJsonEscapedString().c_str() - << '"'; + builder << '{'; + builder << R"("Name": "Negotiate500", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("AccessKeyID": )"; - builder << '"' << writer.getAccessKeyIDAsJsonEscapedString().c_str() - << '"'; + builder << R"("HMACSignature": )"; + builder << '"' << + writer.getHMACSignatureAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << ", "; + builder << R"("AccessKeyID": )"; + builder << '"' << + writer.getAccessKeyIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("Session": )"; - builder << '"' << writer.getSessionAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << ", "; - builder << R"("Firm": )"; - builder << '"' << writer.getFirmAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Session": )"; + builder << '"' << + writer.getSessionAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("Credentials": )"; - builder << '"' << writer.getCredentialsAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("Firm": )"; + builder << '"' << + writer.getFirmAsJsonEscapedString().c_str() << '"'; - builder << '}'; + builder << ", "; + builder << R"("Credentials": )"; + builder << '"' << + writer.getCredentialsAsJsonEscapedString().c_str() << '"'; - return builder; - } + builder << '}'; - void skip() { skipCredentials(); } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } +void skip() +{ + skipCredentials(); +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t CredentialsLength = 0) { +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t credentialsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += credentialsHeaderLength(); - if (CredentialsLength > 65534) { - throw std::runtime_error( - "CredentialsLength too long for length type [E109]"); - } - length += CredentialsLength; - return length; + length += credentialsHeaderLength(); + if (credentialsLength > 65534LL) + { + throw std::runtime_error("credentialsLength too long for length type [E109]"); + } + length += credentialsLength; + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/NegotiationReject502.h b/src/lib/orderman/ilink3/generated/NegotiationReject502.h index fe578350d..4415f3bfa 100644 --- a/src/lib/orderman/ilink3/generated/NegotiationReject502.h +++ b/src/lib/orderman/ilink3/generated/NegotiationReject502.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,767 +86,878 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class NegotiationReject502 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class NegotiationReject502 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(68); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(502); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - NegotiationReject502() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - NegotiationReject502( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - NegotiationReject502(char *buffer, const std::uint64_t bufferLength) - : NegotiationReject502( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + NegotiationReject502() = default; - NegotiationReject502( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : NegotiationReject502( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + NegotiationReject502( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)68; - } + NegotiationReject502(char *buffer, const std::uint64_t bufferLength) : + NegotiationReject502(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + NegotiationReject502( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + NegotiationReject502(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)502; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(68); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(502); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "NegotiationReject"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - NegotiationReject502 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = NegotiationReject502( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "NegotiationReject"; + } - NegotiationReject502 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + NegotiationReject502 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = NegotiationReject502(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = NegotiationReject502( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + NegotiationReject502 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - NegotiationReject502 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = NegotiationReject502( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = NegotiationReject502( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NegotiationReject502 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = NegotiationReject502(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + NegotiationReject502 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - NegotiationReject502 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + NegotiationReject502 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t reasonId() SBE_NOEXCEPT { return 39011; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - reasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool reasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t reasonId() SBE_NOEXCEPT + { + return 39011; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool reasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= reasonSinceVersion(); + return m_actingVersion >= reasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - reasonEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reasonEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT { - return 48; - } + static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t reasonLength() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint64_t reasonLength() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD const char *reason() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } + SBE_NODISCARD const char *reason() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char *reason() SBE_NOEXCEPT { return m_buffer + m_offset + 0; } + SBE_NODISCARD char *reason() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char reason(const std::uint64_t index) const { - if (index >= 48) { - throw std::runtime_error("index out of range for reason [E104]"); - } + SBE_NODISCARD char reason(const std::uint64_t index) const + { + if (index >= 48) + { + throw std::runtime_error("index out of range for reason [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - NegotiationReject502 &reason(const std::uint64_t index, const char value) { - if (index >= 48) { - throw std::runtime_error("index out of range for reason [E105]"); - } + NegotiationReject502 &reason(const std::uint64_t index, const char value) + { + if (index >= 48) + { + throw std::runtime_error("index out of range for reason [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getReason(char *const dst, const std::uint64_t length) const { - if (length > 48) { - throw std::runtime_error("length too large for getReason [E106]"); - } + std::uint64_t getReason(char *const dst, const std::uint64_t length) const + { + if (length > 48) + { + throw std::runtime_error("length too large for getReason [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - NegotiationReject502 &putReason(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 48); - return *this; - } + NegotiationReject502 &putReason(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 48); + return *this; + } - SBE_NODISCARD std::string getReasonAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + SBE_NODISCARD std::string getReasonAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 48 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 48 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getReasonAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getReasonAsString(); + std::string getReasonAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getReasonAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 48 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 48 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NegotiationReject502 &putReason(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 48) { - throw std::runtime_error("string too large for putReason [E106]"); - } + #if __cplusplus >= 201703L + NegotiationReject502 &putReason(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 48) + { + throw std::runtime_error("string too large for putReason [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 48; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 48; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#else - NegotiationReject502 &putReason(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 48) { - throw std::runtime_error("string too large for putReason [E106]"); - } + return *this; + } + #else + NegotiationReject502 &putReason(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 48) + { + throw std::runtime_error("string too large for putReason [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 48; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 48; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 48; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NegotiationReject502 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); - return *this; - } + NegotiationReject502 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 56; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 56; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NegotiationReject502 & - requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); - return *this; - } + NegotiationReject502 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t errorCodesId() SBE_NOEXCEPT { - return 39012; - } + static SBE_CONSTEXPR std::uint16_t errorCodesId() SBE_NOEXCEPT + { + return 39012; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - errorCodesSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t errorCodesSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool errorCodesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool errorCodesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= errorCodesSinceVersion(); + return m_actingVersion >= errorCodesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - errorCodesEncodingOffset() SBE_NOEXCEPT { - return 64; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t errorCodesEncodingOffset() SBE_NOEXCEPT + { + return 64; + } - static SBE_CONSTEXPR std::uint16_t errorCodesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t errorCodesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t errorCodes() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t errorCodes() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - NegotiationReject502 &errorCodes(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint16_t)); - return *this; - } + NegotiationReject502 &errorCodes(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT { - return 39010; - } + static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT + { + return 39010; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= faultToleranceIndicatorSinceVersion(); + return m_actingVersion >= faultToleranceIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT { - return 66; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 66; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD FTI::Value faultToleranceIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); - return FTI::get((val)); - } + SBE_NODISCARD std::uint8_t faultToleranceIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return (val); + } - NegotiationReject502 & - faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD FTI::Value faultToleranceIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return FTI::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NegotiationReject502 &faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 67; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 67; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); + return (val); + } - NegotiationReject502 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - NegotiationReject502 _writer) { - NegotiationReject502 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "NegotiationReject502", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + NegotiationReject502 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("Reason": )"; - builder << '"' << writer.getReasonAsJsonEscapedString().c_str() << '"'; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NegotiationReject502 _writer) +{ + NegotiationReject502 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << '{'; + builder << R"("Name": "NegotiationReject502", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << R"("Reason": )"; + builder << '"' << + writer.getReasonAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ErrorCodes": )"; - builder << +writer.errorCodes(); + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("FaultToleranceIndicator": )"; - builder << '"' << writer.faultToleranceIndicator() << '"'; + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("ErrorCodes": )"; + builder << +writer.errorCodes(); - builder << '}'; + builder << ", "; + builder << R"("FaultToleranceIndicator": )"; + builder << '"' << writer.faultToleranceIndicator() << '"'; - return builder; - } + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - void skip() {} + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/NegotiationResponse501.h b/src/lib/orderman/ilink3/generated/NegotiationResponse501.h index a1797c4b1..5d78d93e3 100644 --- a/src/lib/orderman/ilink3/generated/NegotiationResponse501.h +++ b/src/lib/orderman/ilink3/generated/NegotiationResponse501.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1056 +86,1138 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class NegotiationResponse501 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class NegotiationResponse501 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(32); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(501); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - NegotiationResponse501() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - NegotiationResponse501( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - NegotiationResponse501(char *buffer, const std::uint64_t bufferLength) - : NegotiationResponse501( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + NegotiationResponse501() = default; - NegotiationResponse501( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : NegotiationResponse501( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + NegotiationResponse501( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)32; - } + NegotiationResponse501(char *buffer, const std::uint64_t bufferLength) : + NegotiationResponse501(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + NegotiationResponse501( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + NegotiationResponse501(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)501; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(32); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(501); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "NegotiationResponse"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - NegotiationResponse501 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = NegotiationResponse501( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "NegotiationResponse"; + } - NegotiationResponse501 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + NegotiationResponse501 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = NegotiationResponse501(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = NegotiationResponse501( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + NegotiationResponse501 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - NegotiationResponse501 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = NegotiationResponse501( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = NegotiationResponse501( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NegotiationResponse501 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = NegotiationResponse501(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + NegotiationResponse501 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - NegotiationResponse501 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + NegotiationResponse501 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - ServerFlowMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t serverFlowId() SBE_NOEXCEPT { - return 39009; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - serverFlowSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool serverFlowInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *ServerFlowMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t serverFlowId() SBE_NOEXCEPT + { + return 39009; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t serverFlowSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool serverFlowInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= serverFlowSinceVersion(); + return m_actingVersion >= serverFlowSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - serverFlowEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t serverFlowEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char serverFlowNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char serverFlowNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char serverFlowMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char serverFlowMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char serverFlowMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char serverFlowMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t serverFlowEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t serverFlowEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t serverFlowLength() SBE_NOEXCEPT { - return 11; - } + static SBE_CONSTEXPR std::uint64_t serverFlowLength() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD const char *serverFlow() const { - static const std::uint8_t serverFlowValues[] = {82, 69, 67, 79, 86, 69, - 82, 65, 66, 76, 69}; + SBE_NODISCARD const char *serverFlow() const + { + static const std::uint8_t serverFlowValues[] = { 82, 69, 67, 79, 86, 69, 82, 65, 66, 76, 69, 0 }; - return (const char *)serverFlowValues; - } + return (const char *)serverFlowValues; + } - SBE_NODISCARD char serverFlow(const std::uint64_t index) const { - static const std::uint8_t serverFlowValues[] = {82, 69, 67, 79, 86, 69, - 82, 65, 66, 76, 69}; + SBE_NODISCARD char serverFlow(const std::uint64_t index) const + { + static const std::uint8_t serverFlowValues[] = { 82, 69, 67, 79, 86, 69, 82, 65, 66, 76, 69, 0 }; - return (char)serverFlowValues[index]; - } + return (char)serverFlowValues[index]; + } - std::uint64_t getServerFlow(char *dst, const std::uint64_t length) const { - static std::uint8_t serverFlowValues[] = {82, 69, 67, 79, 86, 69, - 82, 65, 66, 76, 69}; - std::uint64_t bytesToCopy = - length < sizeof(serverFlowValues) ? length : sizeof(serverFlowValues); + std::uint64_t getServerFlow(char *dst, const std::uint64_t length) const + { + static std::uint8_t serverFlowValues[] = { 82, 69, 67, 79, 86, 69, 82, 65, 66, 76, 69 }; + std::uint64_t bytesToCopy = length < sizeof(serverFlowValues) ? length : sizeof(serverFlowValues); - std::memcpy(dst, serverFlowValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, serverFlowValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getServerFlowAsString() const { - static const std::uint8_t ServerFlowValues[] = {82, 69, 67, 79, 86, 69, - 82, 65, 66, 76, 69}; + std::string getServerFlowAsString() const + { + static const std::uint8_t ServerFlowValues[] = { 82, 69, 67, 79, 86, 69, 82, 65, 66, 76, 69 }; - return std::string((const char *)ServerFlowValues, 11); - } + return std::string((const char *)ServerFlowValues, 11); + } - std::string getServerFlowAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getServerFlowAsString(); + std::string getServerFlowAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getServerFlowAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NegotiationResponse501 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + NegotiationResponse501 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NegotiationResponse501 & - requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + NegotiationResponse501 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SecretKeySecureIDExpirationMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecretKeySecureIDExpirationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t - secretKeySecureIDExpirationId() SBE_NOEXCEPT { - return 39022; - } + static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationId() SBE_NOEXCEPT + { + return 39022; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - secretKeySecureIDExpirationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t secretKeySecureIDExpirationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool - secretKeySecureIDExpirationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool secretKeySecureIDExpirationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= secretKeySecureIDExpirationSinceVersion(); + return m_actingVersion >= secretKeySecureIDExpirationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - secretKeySecureIDExpirationEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t secretKeySecureIDExpirationEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - static SBE_CONSTEXPR std::uint16_t - secretKeySecureIDExpirationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t - secretKeySecureIDExpirationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t - secretKeySecureIDExpirationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t secretKeySecureIDExpirationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - secretKeySecureIDExpirationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t secretKeySecureIDExpirationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t - secretKeySecureIDExpiration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t secretKeySecureIDExpiration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - NegotiationResponse501 & - secretKeySecureIDExpiration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint16_t)); - return *this; - } + NegotiationResponse501 &secretKeySecureIDExpiration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT { - return 39010; - } + static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT + { + return 39010; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= faultToleranceIndicatorSinceVersion(); + return m_actingVersion >= faultToleranceIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT { - return 18; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 18; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD FTI::Value faultToleranceIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); - return FTI::get((val)); - } + SBE_NODISCARD std::uint8_t faultToleranceIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return (val); + } - NegotiationResponse501 & - faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 18, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD FTI::Value faultToleranceIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return FTI::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NegotiationResponse501 &faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 18, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 19; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 19; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t)); + return (val); + } - NegotiationResponse501 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 19, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char * - PreviousSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NegotiationResponse501 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 19, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t previousSeqNoId() SBE_NOEXCEPT { - return 39021; - } + SBE_NODISCARD static const char *PreviousSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - previousSeqNoSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t previousSeqNoId() SBE_NOEXCEPT + { + return 39021; + } - SBE_NODISCARD bool previousSeqNoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t previousSeqNoSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool previousSeqNoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= previousSeqNoSinceVersion(); + return m_actingVersion >= previousSeqNoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - previousSeqNoEncodingOffset() SBE_NOEXCEPT { - return 20; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t previousSeqNoEncodingOffset() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint32_t previousSeqNoNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t previousSeqNoNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t previousSeqNoMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t previousSeqNoMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t previousSeqNoEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t previousSeqNo() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t previousSeqNo() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NegotiationResponse501 & - previousSeqNo(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint32_t)); - return *this; - } + NegotiationResponse501 &previousSeqNo(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - PreviousUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PreviousUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t previousUUIDId() SBE_NOEXCEPT { - return 39015; - } + static SBE_CONSTEXPR std::uint16_t previousUUIDId() SBE_NOEXCEPT + { + return 39015; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - previousUUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t previousUUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool previousUUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool previousUUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= previousUUIDSinceVersion(); + return m_actingVersion >= previousUUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - previousUUIDEncodingOffset() SBE_NOEXCEPT { - return 24; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t previousUUIDEncodingOffset() SBE_NOEXCEPT + { + return 24; + } - static SBE_CONSTEXPR std::uint64_t previousUUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t previousUUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t previousUUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t previousUUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t previousUUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t previousUUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t previousUUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NegotiationResponse501 & - previousUUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint64_t)); - return *this; - } + NegotiationResponse501 &previousUUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "data"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CredentialsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "data"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static const char *credentialsCharacterEncoding() SBE_NOEXCEPT { - return "US-ASCII"; - } + static const char *credentialsCharacterEncoding() SBE_NOEXCEPT + { + return "US-ASCII"; + } - static SBE_CONSTEXPR std::uint64_t credentialsSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t credentialsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - bool credentialsInActingVersion() SBE_NOEXCEPT { + bool credentialsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= credentialsSinceVersion(); + return m_actingVersion >= credentialsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - static SBE_CONSTEXPR std::uint16_t credentialsId() SBE_NOEXCEPT { - return 39008; - } + static SBE_CONSTEXPR std::uint16_t credentialsId() SBE_NOEXCEPT + { + return 39008; + } - static SBE_CONSTEXPR std::uint64_t credentialsHeaderLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint64_t credentialsHeaderLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t credentialsLength() const { - std::uint16_t length; - std::memcpy(&length, m_buffer + sbePosition(), sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(length); - } + SBE_NODISCARD std::uint16_t credentialsLength() const + { + std::uint16_t length; + std::memcpy(&length, m_buffer + sbePosition(), sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(length); + } - std::uint64_t skipCredentials() { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - sbePosition(lengthPosition + lengthOfLengthField + dataLength); - return dataLength; - } + std::uint64_t skipCredentials() + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + sbePosition(lengthPosition + lengthOfLengthField + dataLength); + return dataLength; + } - SBE_NODISCARD const char *credentials() { - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + sbePosition(), sizeof(std::uint16_t)); - const char *fieldPtr = m_buffer + sbePosition() + 2; - sbePosition( - sbePosition() + 2 + SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue)); - return fieldPtr; - } + SBE_NODISCARD const char *credentials() + { + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + sbePosition(), sizeof(std::uint16_t)); + const char *fieldPtr = m_buffer + sbePosition() + 2; + sbePosition(sbePosition() + 2 + SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue)); + return fieldPtr; + } - std::uint64_t getCredentials(char *dst, const std::uint64_t length) { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - sbePosition(lengthPosition + lengthOfLengthField); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - std::uint64_t bytesToCopy = length < dataLength ? length : dataLength; - std::uint64_t pos = sbePosition(); - sbePosition(pos + dataLength); - std::memcpy(dst, m_buffer + pos, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::uint64_t getCredentials(char *dst, const std::uint64_t length) + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + sbePosition(lengthPosition + lengthOfLengthField); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + std::uint64_t bytesToCopy = length < dataLength ? length : dataLength; + std::uint64_t pos = sbePosition(); + sbePosition(pos + dataLength); + std::memcpy(dst, m_buffer + pos, static_cast(bytesToCopy)); + return bytesToCopy; + } - NegotiationResponse501 & - putCredentials(const char *src, const std::uint16_t length) { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - std::uint16_t lengthFieldValue = SBE_LITTLE_ENDIAN_ENCODE_16(length); - sbePosition(lengthPosition + lengthOfLengthField); - std::memcpy( - m_buffer + lengthPosition, &lengthFieldValue, sizeof(std::uint16_t)); - if (length != std::uint16_t(0)) { - std::uint64_t pos = sbePosition(); - sbePosition(pos + length); - std::memcpy(m_buffer + pos, src, length); - } - return *this; - } + NegotiationResponse501 &putCredentials(const char *src, const std::uint16_t length) + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + std::uint16_t lengthFieldValue = SBE_LITTLE_ENDIAN_ENCODE_16(length); + sbePosition(lengthPosition + lengthOfLengthField); + std::memcpy(m_buffer + lengthPosition, &lengthFieldValue, sizeof(std::uint16_t)); + if (length != std::uint16_t(0)) + { + std::uint64_t pos = sbePosition(); + sbePosition(pos + length); + std::memcpy(m_buffer + pos, src, length); + } + return *this; + } - std::string getCredentialsAsString() { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - sbePosition(lengthPosition + lengthOfLengthField); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - std::uint64_t pos = sbePosition(); - const std::string result(m_buffer + pos, dataLength); - sbePosition(pos + dataLength); - return result; - } + std::string getCredentialsAsString() + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + sbePosition(lengthPosition + lengthOfLengthField); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + std::uint64_t pos = sbePosition(); + const std::string result(m_buffer + pos, dataLength); + sbePosition(pos + dataLength); + return result; + } - std::string getCredentialsAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCredentialsAsString(); + std::string getCredentialsAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCredentialsAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - std::string_view getCredentialsAsStringView() { - std::uint64_t lengthOfLengthField = 2; - std::uint64_t lengthPosition = sbePosition(); - sbePosition(lengthPosition + lengthOfLengthField); - std::uint16_t lengthFieldValue; - std::memcpy( - &lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); - std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); - std::uint64_t pos = sbePosition(); - const std::string_view result(m_buffer + pos, dataLength); - sbePosition(pos + dataLength); - return result; - } -#endif + #if __cplusplus >= 201703L + std::string_view getCredentialsAsStringView() + { + std::uint64_t lengthOfLengthField = 2; + std::uint64_t lengthPosition = sbePosition(); + sbePosition(lengthPosition + lengthOfLengthField); + std::uint16_t lengthFieldValue; + std::memcpy(&lengthFieldValue, m_buffer + lengthPosition, sizeof(std::uint16_t)); + std::uint64_t dataLength = SBE_LITTLE_ENDIAN_ENCODE_16(lengthFieldValue); + std::uint64_t pos = sbePosition(); + const std::string_view result(m_buffer + pos, dataLength); + sbePosition(pos + dataLength); + return result; + } + #endif - NegotiationResponse501 &putCredentials(const std::string &str) { - if (str.length() > 65534) { - throw std::runtime_error( - "std::string too long for length type [E109]"); - } - return putCredentials( - str.data(), static_cast(str.length())); - } + NegotiationResponse501 &putCredentials(const std::string &str) + { + if (str.length() > 65534) + { + throw std::runtime_error("std::string too long for length type [E109]"); + } + return putCredentials(str.data(), static_cast(str.length())); + } -#if __cplusplus >= 201703L - NegotiationResponse501 &putCredentials(const std::string_view str) { - if (str.length() > 65534) { - throw std::runtime_error( - "std::string too long for length type [E109]"); - } - return putCredentials( - str.data(), static_cast(str.length())); - } -#endif + #if __cplusplus >= 201703L + NegotiationResponse501 &putCredentials(const std::string_view str) + { + if (str.length() > 65534) + { + throw std::runtime_error("std::string too long for length type [E109]"); + } + return putCredentials(str.data(), static_cast(str.length())); + } + #endif - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - NegotiationResponse501 _writer) { - NegotiationResponse501 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "NegotiationResponse501", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NegotiationResponse501 _writer) +{ + NegotiationResponse501 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << '{'; + builder << R"("Name": "NegotiationResponse501", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("SecretKeySecureIDExpiration": )"; - builder << +writer.secretKeySecureIDExpiration(); + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << ", "; - builder << R"("FaultToleranceIndicator": )"; - builder << '"' << writer.faultToleranceIndicator() << '"'; + builder << ", "; + builder << R"("SecretKeySecureIDExpiration": )"; + builder << +writer.secretKeySecureIDExpiration(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("FaultToleranceIndicator": )"; + builder << '"' << writer.faultToleranceIndicator() << '"'; - builder << ", "; - builder << R"("PreviousSeqNo": )"; - builder << +writer.previousSeqNo(); + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - builder << ", "; - builder << R"("PreviousUUID": )"; - builder << +writer.previousUUID(); + builder << ", "; + builder << R"("PreviousSeqNo": )"; + builder << +writer.previousSeqNo(); - builder << ", "; - builder << R"("Credentials": )"; - builder << '"' << writer.getCredentialsAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("PreviousUUID": )"; + builder << +writer.previousUUID(); - builder << '}'; + builder << ", "; + builder << R"("Credentials": )"; + builder << '"' << + writer.getCredentialsAsJsonEscapedString().c_str() << '"'; - return builder; - } + builder << '}'; - void skip() { skipCredentials(); } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } +void skip() +{ + skipCredentials(); +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t CredentialsLength = 0) { +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t credentialsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += credentialsHeaderLength(); - if (CredentialsLength > 65534) { - throw std::runtime_error( - "CredentialsLength too long for length type [E109]"); - } - length += CredentialsLength; - return length; + length += credentialsHeaderLength(); + if (credentialsLength > 65534LL) + { + throw std::runtime_error("credentialsLength too long for length type [E109]"); + } + length += credentialsLength; + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/NewOrderCross544.h b/src/lib/orderman/ilink3/generated/NewOrderCross544.h index cedc36c69..26f3b9f44 100644 --- a/src/lib/orderman/ilink3/generated/NewOrderCross544.h +++ b/src/lib/orderman/ilink3/generated/NewOrderCross544.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2226 +86,2412 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class NewOrderCross544 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class NewOrderCross544 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(74); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(544); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - NewOrderCross544() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - NewOrderCross544( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - NewOrderCross544(char *buffer, const std::uint64_t bufferLength) - : NewOrderCross544( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + NewOrderCross544() = default; - NewOrderCross544( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : NewOrderCross544( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + NewOrderCross544( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)74; - } + NewOrderCross544(char *buffer, const std::uint64_t bufferLength) : + NewOrderCross544(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + NewOrderCross544( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + NewOrderCross544(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)544; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(74); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(544); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "c"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - NewOrderCross544 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = NewOrderCross544( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "s"; + } - NewOrderCross544 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + NewOrderCross544 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = NewOrderCross544(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = NewOrderCross544( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + NewOrderCross544 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - NewOrderCross544 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = NewOrderCross544( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = NewOrderCross544( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NewOrderCross544 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = NewOrderCross544(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + NewOrderCross544 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - NewOrderCross544 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + NewOrderCross544 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT { return 548; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *CrossIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t crossIDId() SBE_NOEXCEPT + { + return 548; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool crossIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossIDSinceVersion(); + return m_actingVersion >= crossIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t crossIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t crossIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t crossIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t crossIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t crossID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NewOrderCross544 &crossID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + NewOrderCross544 &crossID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NewOrderCross544 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + NewOrderCross544 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - NewOrderCross544 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NewOrderCross544 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NewOrderCross544 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + NewOrderCross544 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - NewOrderCross544 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + NewOrderCross544 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - NewOrderCross544 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + NewOrderCross544 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NewOrderCross544 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + NewOrderCross544 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - NewOrderCross544 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + NewOrderCross544 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR char ordTypeNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char ordTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char ordTypeMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char ordTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char ordTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char ordTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t ordTypeLength() SBE_NOEXCEPT { return 1; } + static SBE_CONSTEXPR std::uint64_t ordTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *ordType() const { - static const std::uint8_t ordTypeValues[] = {50}; + SBE_NODISCARD const char *ordType() const + { + static const std::uint8_t ordTypeValues[] = { 50, 0 }; - return (const char *)ordTypeValues; - } + return (const char *)ordTypeValues; + } - SBE_NODISCARD char ordType(const std::uint64_t index) const { - static const std::uint8_t ordTypeValues[] = {50}; + SBE_NODISCARD char ordType(const std::uint64_t index) const + { + static const std::uint8_t ordTypeValues[] = { 50, 0 }; - return (char)ordTypeValues[index]; - } + return (char)ordTypeValues[index]; + } - std::uint64_t getOrdType(char *dst, const std::uint64_t length) const { - static std::uint8_t ordTypeValues[] = {50}; - std::uint64_t bytesToCopy = - length < sizeof(ordTypeValues) ? length : sizeof(ordTypeValues); + std::uint64_t getOrdType(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordTypeValues[] = { 50 }; + std::uint64_t bytesToCopy = length < sizeof(ordTypeValues) ? length : sizeof(ordTypeValues); - std::memcpy(dst, ordTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, ordTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getOrdTypeAsString() const { - static const std::uint8_t OrdTypeValues[] = {50}; + std::string getOrdTypeAsString() const + { + static const std::uint8_t OrdTypeValues[] = { 50 }; - return std::string((const char *)OrdTypeValues, 1); - } + return std::string((const char *)OrdTypeValues, 1); + } - std::string getOrdTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrdTypeAsString(); + std::string getOrdTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrdTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CrossTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT { return 549; } + static SBE_CONSTEXPR std::uint16_t crossTypeId() SBE_NOEXCEPT + { + return 549; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool crossTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossTypeSinceVersion(); + return m_actingVersion >= crossTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossTypeEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossTypeEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR char crossTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char crossTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char crossTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char crossTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char crossTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char crossTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t crossTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t crossTypeLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t crossTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *crossType() const { - static const std::uint8_t crossTypeValues[] = {51}; + SBE_NODISCARD const char *crossType() const + { + static const std::uint8_t crossTypeValues[] = { 51, 0 }; - return (const char *)crossTypeValues; - } + return (const char *)crossTypeValues; + } - SBE_NODISCARD char crossType(const std::uint64_t index) const { - static const std::uint8_t crossTypeValues[] = {51}; + SBE_NODISCARD char crossType(const std::uint64_t index) const + { + static const std::uint8_t crossTypeValues[] = { 51, 0 }; - return (char)crossTypeValues[index]; - } + return (char)crossTypeValues[index]; + } - std::uint64_t getCrossType(char *dst, const std::uint64_t length) const { - static std::uint8_t crossTypeValues[] = {51}; - std::uint64_t bytesToCopy = - length < sizeof(crossTypeValues) ? length : sizeof(crossTypeValues); + std::uint64_t getCrossType(char *dst, const std::uint64_t length) const + { + static std::uint8_t crossTypeValues[] = { 51 }; + std::uint64_t bytesToCopy = length < sizeof(crossTypeValues) ? length : sizeof(crossTypeValues); - std::memcpy(dst, crossTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, crossTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getCrossTypeAsString() const { - static const std::uint8_t CrossTypeValues[] = {51}; + std::string getCrossTypeAsString() const + { + static const std::uint8_t CrossTypeValues[] = { 51 }; - return std::string((const char *)CrossTypeValues, 1); - } + return std::string((const char *)CrossTypeValues, 1); + } - std::string getCrossTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCrossTypeAsString(); + std::string getCrossTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCrossTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char *CrossPrioritizationMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CrossPrioritizationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t crossPrioritizationId() SBE_NOEXCEPT { - return 550; - } + static SBE_CONSTEXPR std::uint16_t crossPrioritizationId() SBE_NOEXCEPT + { + return 550; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - crossPrioritizationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t crossPrioritizationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool crossPrioritizationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool crossPrioritizationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= crossPrioritizationSinceVersion(); + return m_actingVersion >= crossPrioritizationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - crossPrioritizationEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t crossPrioritizationEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR char crossPrioritizationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char crossPrioritizationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char crossPrioritizationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char crossPrioritizationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char crossPrioritizationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char crossPrioritizationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - crossPrioritizationEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t crossPrioritizationEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t crossPrioritizationLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t crossPrioritizationLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *crossPrioritization() const { - static const std::uint8_t crossPrioritizationValues[] = {48}; + SBE_NODISCARD const char *crossPrioritization() const + { + static const std::uint8_t crossPrioritizationValues[] = { 48, 0 }; - return (const char *)crossPrioritizationValues; - } + return (const char *)crossPrioritizationValues; + } - SBE_NODISCARD char crossPrioritization(const std::uint64_t index) const { - static const std::uint8_t crossPrioritizationValues[] = {48}; + SBE_NODISCARD char crossPrioritization(const std::uint64_t index) const + { + static const std::uint8_t crossPrioritizationValues[] = { 48, 0 }; - return (char)crossPrioritizationValues[index]; - } + return (char)crossPrioritizationValues[index]; + } - std::uint64_t - getCrossPrioritization(char *dst, const std::uint64_t length) const { - static std::uint8_t crossPrioritizationValues[] = {48}; - std::uint64_t bytesToCopy = length < sizeof(crossPrioritizationValues) - ? length - : sizeof(crossPrioritizationValues); + std::uint64_t getCrossPrioritization(char *dst, const std::uint64_t length) const + { + static std::uint8_t crossPrioritizationValues[] = { 48 }; + std::uint64_t bytesToCopy = length < sizeof(crossPrioritizationValues) ? length : sizeof(crossPrioritizationValues); - std::memcpy( - dst, crossPrioritizationValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, crossPrioritizationValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getCrossPrioritizationAsString() const { - static const std::uint8_t CrossPrioritizationValues[] = {48}; + std::string getCrossPrioritizationAsString() const + { + static const std::uint8_t CrossPrioritizationValues[] = { 48 }; - return std::string((const char *)CrossPrioritizationValues, 1); - } + return std::string((const char *)CrossPrioritizationValues, 1); + } - std::string getCrossPrioritizationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCrossPrioritizationAsString(); + std::string getCrossPrioritizationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCrossPrioritizationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceSinceVersion(); + return m_actingVersion >= priceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - private: - PRICE9 m_price; +private: + PRICE9 m_price; - public: - SBE_NODISCARD PRICE9 &price() { - m_price.wrap(m_buffer, m_offset + 41, m_actingVersion, m_bufferLength); - return m_price; - } +public: + SBE_NODISCARD PRICE9 &price() + { + m_price.wrap(m_buffer, m_offset + 41, m_actingVersion, m_bufferLength); + return m_price; + } - SBE_NODISCARD static const char * - TransBkdTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransBkdTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transBkdTimeId() SBE_NOEXCEPT { - return 483; - } + static SBE_CONSTEXPR std::uint16_t transBkdTimeId() SBE_NOEXCEPT + { + return 483; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transBkdTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transBkdTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transBkdTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transBkdTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transBkdTimeSinceVersion(); + return m_actingVersion >= transBkdTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transBkdTimeEncodingOffset() SBE_NOEXCEPT { - return 49; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transBkdTimeEncodingOffset() SBE_NOEXCEPT + { + return 49; + } - static SBE_CONSTEXPR std::uint64_t transBkdTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transBkdTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transBkdTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transBkdTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transBkdTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transBkdTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transBkdTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transBkdTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transBkdTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 49, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transBkdTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 49, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NewOrderCross544 &transBkdTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 49, &val, sizeof(std::uint64_t)); - return *this; - } + NewOrderCross544 &transBkdTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 49, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 57; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 57; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 57, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 57, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NewOrderCross544 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 57, &val, sizeof(std::uint64_t)); - return *this; - } + NewOrderCross544 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 57, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 65 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 65 + (index * 1), sizeof(char)); + return (val); + } - NewOrderCross544 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + NewOrderCross544 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 65 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 65 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 65, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 65, sizeof(char) * static_cast(length)); + return length; + } - NewOrderCross544 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 5); - return *this; - } + NewOrderCross544 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 65; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 65; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NewOrderCross544 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + NewOrderCross544 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#else - NewOrderCross544 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + NewOrderCross544 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 70; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 70; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NewOrderCross544 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 70, &val, sizeof(std::int32_t)); - return *this; - } + NewOrderCross544 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 70, &val, sizeof(std::int32_t)); + return *this; + } - class NoSides { + class NoSides + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)34); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 34; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 34; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoSides &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= clOrdIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoSides &clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoSides &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoSides &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoSides &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoSides &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { - return 38; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 28; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoSides &orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t)); - return SideReq::get((val)); - } - - NoSides &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *SideTimeInForceMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideTimeInForceId() SBE_NOEXCEPT { - return 962; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideTimeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideTimeInForceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideTimeInForceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideTimeInForceEncodingOffset() SBE_NOEXCEPT { - return 33; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideTimeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideTimeInForce::Value - sideTimeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 33, sizeof(std::uint8_t)); - return SideTimeInForce::get((val)); - } - - NoSides & - sideTimeInForce(const SideTimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 33, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoSides writer) { - builder << '{'; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); - - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; - - builder << ", "; - builder << R"("SideTimeInForce": )"; - builder << '"' << writer.sideTimeInForce() << '"'; - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoSides m_noSides; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoSidesId() SBE_NOEXCEPT { - return 552; - } - - SBE_NODISCARD inline NoSides &noSides() { - m_noSides.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noSides; - } - - NoSides &noSidesCount(const std::uint8_t count) { - m_noSides.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noSides; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noSidesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noSidesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noSidesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NewOrderCross544 _writer) { - NewOrderCross544 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "NewOrderCross544", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("CrossID": )"; - builder << +writer.crossID(); - - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("Price": )"; - builder << writer.price(); - - builder << ", "; - builder << R"("TransBkdTime": )"; - builder << +writer.transBkdTime(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoSides": [)"; - writer.noSides().forEach([&](NoSides &noSides) { - if (atLeastOne) { - builder << ", "; + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(34)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 34; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 34; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); } - atLeastOne = true; - builder << noSides; - }); - builder << ']'; - } + return position; + } - builder << '}'; + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - return builder; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - void skip() { - noSides().forEach([](NoSides e) { e.skip(); }); - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + inline NoSides &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t NoSidesLength = 0) { + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= clOrdIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } + + NoSides &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoSides &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoSides &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoSides &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoSides &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoSides &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= sideSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + NoSides &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SideTimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideTimeInForceId() SBE_NOEXCEPT + { + return 962; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideTimeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideTimeInForceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= sideTimeInForceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideTimeInForceEncodingOffset() SBE_NOEXCEPT + { + return 33; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideTimeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideTimeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 33, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideTimeInForce::Value sideTimeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 33, sizeof(std::uint8_t)); + return SideTimeInForce::get((val)); + } + + NoSides &sideTimeInForce(const SideTimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 33, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoSides writer) + { + builder << '{'; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("SideTimeInForce": )"; + builder << '"' << writer.sideTimeInForce() << '"'; + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoSides::sbeHeaderSize(); - if (NoSidesLength > 254) { - throw std::runtime_error( - "NoSidesLength outside of allowed range [E110]"); - } - length += NoSidesLength * NoSides::sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } + } + }; + +private: + NoSides m_noSides; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoSidesId() SBE_NOEXCEPT + { + return 552; + } + + SBE_NODISCARD inline NoSides &noSides() + { + m_noSides.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noSides; + } + + NoSides &noSidesCount(const std::uint8_t count) + { + m_noSides.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noSides; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noSidesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noSidesInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noSidesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NewOrderCross544 _writer) +{ + NewOrderCross544 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "NewOrderCross544", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("CrossID": )"; + builder << +writer.crossID(); + + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Price": )"; + builder << writer.price(); + + builder << ", "; + builder << R"("TransBkdTime": )"; + builder << +writer.transBkdTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoSides": [)"; + writer.noSides().forEach( + [&](NoSides &noSides) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noSides; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noSidesGroup { noSides() }; + while (noSidesGroup.hasNext()) + { + noSidesGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noSidesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoSides::sbeHeaderSize(); + if (noSidesLength > 254LL) + { + throw std::runtime_error("noSidesLength outside of allowed range [E110]"); + } + length += noSidesLength *NoSides::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/NewOrderSingle514.h b/src/lib/orderman/ilink3/generated/NewOrderSingle514.h index c8342e787..d59dc3055 100644 --- a/src/lib/orderman/ilink3/generated/NewOrderSingle514.h +++ b/src/lib/orderman/ilink3/generated/NewOrderSingle514.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2082 +86,2426 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class NewOrderSingle514 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class NewOrderSingle514 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(132); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(514); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - NewOrderSingle514() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - NewOrderSingle514( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - NewOrderSingle514(char *buffer, const std::uint64_t bufferLength) - : NewOrderSingle514( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + NewOrderSingle514() = default; - NewOrderSingle514( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : NewOrderSingle514( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + NewOrderSingle514( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)116; - } + NewOrderSingle514(char *buffer, const std::uint64_t bufferLength) : + NewOrderSingle514(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + NewOrderSingle514( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + NewOrderSingle514(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)514; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(132); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(514); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "D"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - NewOrderSingle514 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = NewOrderSingle514( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "D"; + } - NewOrderSingle514 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + NewOrderSingle514 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = NewOrderSingle514(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = NewOrderSingle514( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + NewOrderSingle514 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - NewOrderSingle514 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = NewOrderSingle514( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = NewOrderSingle514( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NewOrderSingle514 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = NewOrderSingle514(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + NewOrderSingle514 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - NewOrderSingle514 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + NewOrderSingle514 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceSinceVersion(); + return m_actingVersion >= priceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICENULL9 m_price; +private: + PRICENULL9 m_price; - public: - SBE_NODISCARD PRICENULL9 &price() { - m_price.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_price; - } +public: + SBE_NODISCARD PRICENULL9 &price() + { + m_price.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_price; + } - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderQtySinceVersion(); + return m_actingVersion >= orderQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NewOrderSingle514 &orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + NewOrderSingle514 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NewOrderSingle514 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 12, &val, sizeof(std::int32_t)); - return *this; - } + NewOrderSingle514 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 12, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - NewOrderSingle514 &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NewOrderSingle514 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NewOrderSingle514 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + NewOrderSingle514 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - NewOrderSingle514 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + NewOrderSingle514 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - NewOrderSingle514 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + NewOrderSingle514 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NewOrderSingle514 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + NewOrderSingle514 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - NewOrderSingle514 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + NewOrderSingle514 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 41; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 41; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 41; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 41; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 41 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 41 + (index * 1), sizeof(char)); + return (val); + } - NewOrderSingle514 &clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + NewOrderSingle514 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 41 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 41 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 41, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast(length)); + return length; + } - NewOrderSingle514 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 41, src, sizeof(char) * 20); - return *this; - } + NewOrderSingle514 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 41, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 41; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 41; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 41; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 41; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NewOrderSingle514 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + NewOrderSingle514 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 41 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 41 + start] = 0; + } - return *this; - } -#else - NewOrderSingle514 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + NewOrderSingle514 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 41 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 41 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 61; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 61; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NewOrderSingle514 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint64_t)); - return *this; - } + NewOrderSingle514 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 69; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 69; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NewOrderSingle514 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint64_t)); - return *this; - } + NewOrderSingle514 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 77; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 77; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 77, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 77, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NewOrderSingle514 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 77, &val, sizeof(std::uint64_t)); - return *this; - } + NewOrderSingle514 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 77, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= stopPxSinceVersion(); + return m_actingVersion >= stopPxSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 85; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 85; + } - private: - PRICENULL9 m_stopPx; +private: + PRICENULL9 m_stopPx; - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 85, m_actingVersion, m_bufferLength); - return m_stopPx; - } +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 85, m_actingVersion, m_bufferLength); + return m_stopPx; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 93; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 93; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 93; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 93; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 93; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 93; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 93 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 93 + (index * 1), sizeof(char)); + return (val); + } - NewOrderSingle514 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + NewOrderSingle514 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 93 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 93 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 93, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 93, sizeof(char) * static_cast(length)); + return length; + } - NewOrderSingle514 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 93, src, sizeof(char) * 5); - return *this; - } + NewOrderSingle514 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 93, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 93; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 93; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 93; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 93; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - NewOrderSingle514 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + NewOrderSingle514 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 93, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 93 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 93, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 93 + start] = 0; + } - return *this; - } -#else - NewOrderSingle514 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + NewOrderSingle514 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 93, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 93 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 93, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 93 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT { return 110; } + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minQtySinceVersion(); + return m_actingVersion >= minQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minQtyEncodingOffset() SBE_NOEXCEPT { - return 98; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 98; + } - static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 98, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 98, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NewOrderSingle514 &minQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 98, &val, sizeof(std::uint32_t)); - return *this; - } + NewOrderSingle514 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 98, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT { - return 1138; - } + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayQtySinceVersion(); + return m_actingVersion >= displayQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayQtyEncodingOffset() SBE_NOEXCEPT { - return 102; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 102; + } - static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 102, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 102, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NewOrderSingle514 &displayQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 102, &val, sizeof(std::uint32_t)); - return *this; - } + NewOrderSingle514 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 102, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= expireDateSinceVersion(); + return m_actingVersion >= expireDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 106; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 106; + } - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 106, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 106, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - NewOrderSingle514 &expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 106, &val, sizeof(std::uint16_t)); - return *this; - } + NewOrderSingle514 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 106, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 108; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 108; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OrderTypeReq::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 108, sizeof(char)); - return OrderTypeReq::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 108, sizeof(char)); + return (val); + } - NewOrderSingle514 &ordType(const OrderTypeReq::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 108, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD OrderTypeReq::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 108, sizeof(char)); + return OrderTypeReq::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NewOrderSingle514 &ordType(const OrderTypeReq::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 108, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 109; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 109; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t)); + return (val); + } - NewOrderSingle514 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 109, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NewOrderSingle514 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 109, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 110; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 110; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t)); + return (val); + } - NewOrderSingle514 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NewOrderSingle514 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execInstSinceVersion(); + return m_actingVersion >= execInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 111; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 111; + } - private: - ExecInst m_execInst; +private: + ExecInst m_execInst; - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); - return m_execInst; - } +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); + return m_execInst; + } - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executionModeSinceVersion(); + return m_actingVersion >= executionModeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 112; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 112; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 112, sizeof(char)); - return ExecMode::get((val)); - } + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 112, sizeof(char)); + return (val); + } - NewOrderSingle514 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 112, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 112, sizeof(char)); + return ExecMode::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NewOrderSingle514 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 112, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 113; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 113; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 113, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 113, sizeof(std::uint8_t)); + return (val); + } - NewOrderSingle514 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 113, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 113, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NewOrderSingle514 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 113, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= managedOrderSinceVersion(); + return m_actingVersion >= managedOrderSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 114; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 114; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 114, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 114, sizeof(std::uint8_t)); + return (val); + } - NewOrderSingle514 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 114, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 114, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + NewOrderSingle514 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 114, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= shortSaleTypeSinceVersion(); + return m_actingVersion >= shortSaleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 115; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 115; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 115, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 115, sizeof(std::uint8_t)); + return (val); + } - NewOrderSingle514 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 115, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 115, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NewOrderSingle514 _writer) { - NewOrderSingle514 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "NewOrderSingle514", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + NewOrderSingle514 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 115, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("Price": )"; - builder << writer.price(); + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 116; + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; +private: + PRICENULL9 m_discretionPrice; - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 116, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + SBE_NODISCARD static const char *ReservationPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + static SBE_CONSTEXPR std::uint16_t reservationPriceId() SBE_NOEXCEPT + { + return 9562; + } - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reservationPriceSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); + SBE_NODISCARD bool reservationPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= reservationPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reservationPriceEncodingOffset() SBE_NOEXCEPT + { + return 124; + } - builder << ", "; - builder << R"("MinQty": )"; - builder << +writer.minQty(); +private: + PRICENULL9 m_reservationPrice; - builder << ", "; - builder << R"("DisplayQty": )"; - builder << +writer.displayQty(); +public: + SBE_NODISCARD PRICENULL9 &reservationPrice() + { + m_reservationPrice.wrap(m_buffer, m_offset + 124, m_actingVersion, m_bufferLength); + return m_reservationPrice; + } - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NewOrderSingle514 _writer) +{ + NewOrderSingle514 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + builder << '{'; + builder << R"("Name": "NewOrderSingle514", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + builder << R"("Price": )"; + builder << writer.price(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << '}'; + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - return builder; - } + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); - void skip() {} + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); + + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); + + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } + + builder << ", "; + builder << R"("ReservationPrice": )"; + if (writer.reservationPriceInActingVersion()) + { + builder << writer.reservationPrice(); + } + else + { + builder << "{}"; + } + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/NotApplied513.h b/src/lib/orderman/ilink3/generated/NotApplied513.h index 1b550224f..d03b5de22 100644 --- a/src/lib/orderman/ilink3/generated/NotApplied513.h +++ b/src/lib/orderman/ilink3/generated/NotApplied513.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,517 +86,600 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class NotApplied513 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class NotApplied513 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(17); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(513); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - NotApplied513() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - NotApplied513( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - NotApplied513(char *buffer, const std::uint64_t bufferLength) - : NotApplied513( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + NotApplied513() = default; - NotApplied513( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : NotApplied513( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + NotApplied513( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)17; - } + NotApplied513(char *buffer, const std::uint64_t bufferLength) : + NotApplied513(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + NotApplied513( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + NotApplied513(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)513; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(17); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(513); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "NotApplied"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - NotApplied513 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = NotApplied513( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "NotApplied"; + } - NotApplied513 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + NotApplied513 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = NotApplied513(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = NotApplied513( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + NotApplied513 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - NotApplied513 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = NotApplied513( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = NotApplied513( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NotApplied513 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = NotApplied513(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + NotApplied513 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - NotApplied513 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + NotApplied513 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - NotApplied513 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + NotApplied513 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - FromSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FromSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fromSeqNoId() SBE_NOEXCEPT { - return 39018; - } + static SBE_CONSTEXPR std::uint16_t fromSeqNoId() SBE_NOEXCEPT + { + return 39018; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fromSeqNoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fromSeqNoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fromSeqNoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool fromSeqNoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fromSeqNoSinceVersion(); + return m_actingVersion >= fromSeqNoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fromSeqNoEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fromSeqNoEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint32_t fromSeqNoNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t fromSeqNoNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t fromSeqNoMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t fromSeqNoMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t fromSeqNoMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t fromSeqNoMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t fromSeqNoEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t fromSeqNoEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t fromSeqNo() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t fromSeqNo() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NotApplied513 &fromSeqNo(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + NotApplied513 &fromSeqNo(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MsgCountMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MsgCountMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t msgCountId() SBE_NOEXCEPT { - return 39019; - } + static SBE_CONSTEXPR std::uint16_t msgCountId() SBE_NOEXCEPT + { + return 39019; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - msgCountSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t msgCountSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool msgCountInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool msgCountInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= msgCountSinceVersion(); + return m_actingVersion >= msgCountSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - msgCountEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t msgCountEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR std::uint32_t msgCountNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t msgCountNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t msgCountMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t msgCountMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t msgCountMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t msgCountMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t msgCountEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t msgCountEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t msgCount() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t msgCount() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - NotApplied513 &msgCount(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 12, &val, sizeof(std::uint32_t)); - return *this; - } + NotApplied513 &msgCount(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 12, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - NotApplied513 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NotApplied513 _writer) { - NotApplied513 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "NotApplied513", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + NotApplied513 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("UUID": )"; - builder << +writer.uUID(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NotApplied513 _writer) +{ + NotApplied513 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("FromSeqNo": )"; - builder << +writer.fromSeqNo(); + builder << '{'; + builder << R"("Name": "NotApplied513", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("MsgCount": )"; - builder << +writer.msgCount(); + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("FromSeqNo": )"; + builder << +writer.fromSeqNo(); - builder << '}'; + builder << ", "; + builder << R"("MsgCount": )"; + builder << +writer.msgCount(); - return builder; - } + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - void skip() {} + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OFMOverrideReq.h b/src/lib/orderman/ilink3/generated/OFMOverrideReq.h index 465218884..81db0c3aa 100644 --- a/src/lib/orderman/ilink3/generated/OFMOverrideReq.h +++ b/src/lib/orderman/ilink3/generated/OFMOverrideReq.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_OFMOVERRIDEREQ_H_ #define _ILINKBINARY_OFMOVERRIDEREQ_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class OFMOverrideReq { - public: - enum Value { - Disabled = (std::uint8_t)0, - Enabled = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class OFMOverrideReq +{ +public: + enum Value + { + Disabled = static_cast(0), + Enabled = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static OFMOverrideReq::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Disabled; - case 1: - return Enabled; - case 255: - return NULL_VALUE; - } + static OFMOverrideReq::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Disabled; + case static_cast(1): return Enabled; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum OFMOverrideReq [E103]"); - } + throw std::runtime_error("unknown value for enum OFMOverrideReq [E103]"); + } - static const char *c_str(const OFMOverrideReq::Value value) { - switch (value) { - case Disabled: - return "Disabled"; - case Enabled: - return "Enabled"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const OFMOverrideReq::Value value) + { + switch (value) + { + case Disabled: return "Disabled"; + case Enabled: return "Enabled"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum OFMOverrideReq [E103]:"); - } + throw std::runtime_error("unknown value for enum OFMOverrideReq [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, OFMOverrideReq::Value m) { - return os << OFMOverrideReq::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, OFMOverrideReq::Value m) + { + return os << OFMOverrideReq::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrdStatusTrd.h b/src/lib/orderman/ilink3/generated/OrdStatusTrd.h index dbf4987e5..95ae74c2b 100644 --- a/src/lib/orderman/ilink3/generated/OrdStatusTrd.h +++ b/src/lib/orderman/ilink3/generated/OrdStatusTrd.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_ORDSTATUSTRD_H_ #define _ILINKBINARY_ORDSTATUSTRD_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class OrdStatusTrd { - public: - enum Value { - PartiallyFilled = (std::uint8_t)1, - Filled = (std::uint8_t)2, - NULL_VALUE = (std::uint8_t)255 - }; +class OrdStatusTrd +{ +public: + enum Value + { + PartiallyFilled = static_cast(1), + Filled = static_cast(2), + NULL_VALUE = static_cast(255) + }; - static OrdStatusTrd::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return PartiallyFilled; - case 2: - return Filled; - case 255: - return NULL_VALUE; - } + static OrdStatusTrd::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return PartiallyFilled; + case static_cast(2): return Filled; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum OrdStatusTrd [E103]"); - } + throw std::runtime_error("unknown value for enum OrdStatusTrd [E103]"); + } - static const char *c_str(const OrdStatusTrd::Value value) { - switch (value) { - case PartiallyFilled: - return "PartiallyFilled"; - case Filled: - return "Filled"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const OrdStatusTrd::Value value) + { + switch (value) + { + case PartiallyFilled: return "PartiallyFilled"; + case Filled: return "Filled"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum OrdStatusTrd [E103]:"); - } + throw std::runtime_error("unknown value for enum OrdStatusTrd [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, OrdStatusTrd::Value m) { - return os << OrdStatusTrd::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, OrdStatusTrd::Value m) + { + return os << OrdStatusTrd::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrdStatusTrdCxl.h b/src/lib/orderman/ilink3/generated/OrdStatusTrdCxl.h index d5d6e360c..c9c2d0159 100644 --- a/src/lib/orderman/ilink3/generated/OrdStatusTrdCxl.h +++ b/src/lib/orderman/ilink3/generated/OrdStatusTrdCxl.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_ORDSTATUSTRDCXL_H_ #define _ILINKBINARY_ORDSTATUSTRDCXL_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,48 +25,48 @@ namespace iLinkBinary { -class OrdStatusTrdCxl { - public: - enum Value { - TradeCorrection = (char)71, - TradeCancel = (char)72, - NULL_VALUE = (char)0 - }; +class OrdStatusTrdCxl +{ +public: + enum Value + { + TradeCorrection = static_cast(71), + TradeCancel = static_cast(72), + NULL_VALUE = static_cast(0) + }; - static OrdStatusTrdCxl::Value get(const char value) { - switch (value) { - case 71: - return TradeCorrection; - case 72: - return TradeCancel; - case 0: - return NULL_VALUE; - } + static OrdStatusTrdCxl::Value get(const char value) + { + switch (value) + { + case static_cast(71): return TradeCorrection; + case static_cast(72): return TradeCancel; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum OrdStatusTrdCxl [E103]"); - } + throw std::runtime_error("unknown value for enum OrdStatusTrdCxl [E103]"); + } - static const char *c_str(const OrdStatusTrdCxl::Value value) { - switch (value) { - case TradeCorrection: - return "TradeCorrection"; - case TradeCancel: - return "TradeCancel"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const OrdStatusTrdCxl::Value value) + { + switch (value) + { + case TradeCorrection: return "TradeCorrection"; + case TradeCancel: return "TradeCancel"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum OrdStatusTrdCxl [E103]:"); - } + throw std::runtime_error("unknown value for enum OrdStatusTrdCxl [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, OrdStatusTrdCxl::Value m) { - return os << OrdStatusTrdCxl::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, OrdStatusTrdCxl::Value m) + { + return os << OrdStatusTrdCxl::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderCancelReject535.h b/src/lib/orderman/ilink3/generated/OrderCancelReject535.h index 4bbd51f20..1f1d6411c 100644 --- a/src/lib/orderman/ilink3/generated/OrderCancelReject535.h +++ b/src/lib/orderman/ilink3/generated/OrderCancelReject535.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2410 +86,2636 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class OrderCancelReject535 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class OrderCancelReject535 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(409); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(535); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - OrderCancelReject535() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - OrderCancelReject535( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - OrderCancelReject535(char *buffer, const std::uint64_t bufferLength) - : OrderCancelReject535( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + OrderCancelReject535() = default; - OrderCancelReject535( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : OrderCancelReject535( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + OrderCancelReject535( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)409; - } + OrderCancelReject535(char *buffer, const std::uint64_t bufferLength) : + OrderCancelReject535(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + OrderCancelReject535( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + OrderCancelReject535(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)535; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(409); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(535); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "9"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - OrderCancelReject535 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = OrderCancelReject535( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "9"; + } - OrderCancelReject535 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + OrderCancelReject535 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = OrderCancelReject535(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = OrderCancelReject535( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + OrderCancelReject535 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - OrderCancelReject535 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = OrderCancelReject535( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = OrderCancelReject535( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + OrderCancelReject535 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = OrderCancelReject535(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + OrderCancelReject535 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - OrderCancelReject535 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + OrderCancelReject535 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderCancelReject535 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + OrderCancelReject535 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReject535 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReject535 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } + static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT + { + return 58; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= textSinceVersion(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 256; + } - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 256; + } - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReject535 &text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } + OrderCancelReject535 &text(const std::uint64_t index, const char value) + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } + std::uint64_t getText(char *const dst, const std::uint64_t length) const + { + if (length > 256) + { + throw std::runtime_error("length too large for getText [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReject535 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } + OrderCancelReject535 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); + return *this; + } - SBE_NODISCARD std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); + std::string getTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTextAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReject535 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReject535 &putText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - OrderCancelReject535 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + return *this; + } + #else + OrderCancelReject535 &putText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 268; + } - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReject535 &execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } + OrderCancelReject535 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReject535 &putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 40); - return *this; - } + OrderCancelReject535 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 40); + return *this; + } - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReject535 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReject535 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#else - OrderCancelReject535 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + return *this; + } + #else + OrderCancelReject535 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 308; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 308; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 308; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 308; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 308; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 308; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 308 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 308 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReject535 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + OrderCancelReject535 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 308 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 308 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 308, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 308, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReject535 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 308, src, sizeof(char) * 20); - return *this; - } + OrderCancelReject535 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 308, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 308; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 308; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 308; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 308; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReject535 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReject535 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 308 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 308 + start] = 0; + } - return *this; - } -#else - OrderCancelReject535 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + OrderCancelReject535 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 308 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 308 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 328; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 328; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 328; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 328; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 328; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 328; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 328 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 328 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReject535 &clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + OrderCancelReject535 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 328 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 328 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 328, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 328, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReject535 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 328, src, sizeof(char) * 20); - return *this; - } + OrderCancelReject535 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 328, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 328; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 328; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 328; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 328; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReject535 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReject535 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 328 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 328 + start] = 0; + } - return *this; - } -#else - OrderCancelReject535 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + OrderCancelReject535 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 328 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 328 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 348; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 348; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReject535 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReject535 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusSinceVersion(); + return m_actingVersion >= ordStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 356; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 356; + } - static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *ordStatus() const { - static const std::uint8_t ordStatusValues[] = {85}; + SBE_NODISCARD const char *ordStatus() const + { + static const std::uint8_t ordStatusValues[] = { 85, 0 }; - return (const char *)ordStatusValues; - } + return (const char *)ordStatusValues; + } - SBE_NODISCARD char ordStatus(const std::uint64_t index) const { - static const std::uint8_t ordStatusValues[] = {85}; + SBE_NODISCARD char ordStatus(const std::uint64_t index) const + { + static const std::uint8_t ordStatusValues[] = { 85, 0 }; - return (char)ordStatusValues[index]; - } + return (char)ordStatusValues[index]; + } - std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const { - static std::uint8_t ordStatusValues[] = {85}; - std::uint64_t bytesToCopy = - length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); + std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordStatusValues[] = { 85 }; + std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); - std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getOrdStatusAsString() const { - static const std::uint8_t OrdStatusValues[] = {85}; + std::string getOrdStatusAsString() const + { + static const std::uint8_t OrdStatusValues[] = { 85 }; - return std::string((const char *)OrdStatusValues, 1); - } + return std::string((const char *)OrdStatusValues, 1); + } - std::string getOrdStatusAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrdStatusAsString(); + std::string getOrdStatusAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrdStatusAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char *CxlRejResponseToMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CxlRejResponseToMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cxlRejResponseToId() SBE_NOEXCEPT { - return 434; - } + static SBE_CONSTEXPR std::uint16_t cxlRejResponseToId() SBE_NOEXCEPT + { + return 434; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cxlRejResponseToSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cxlRejResponseToSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cxlRejResponseToInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cxlRejResponseToInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cxlRejResponseToSinceVersion(); + return m_actingVersion >= cxlRejResponseToSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cxlRejResponseToEncodingOffset() SBE_NOEXCEPT { - return 356; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingOffset() SBE_NOEXCEPT + { + return 356; + } - static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - cxlRejResponseToEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t cxlRejResponseToLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t cxlRejResponseToLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *cxlRejResponseTo() const { - static const std::uint8_t cxlRejResponseToValues[] = {49}; + SBE_NODISCARD const char *cxlRejResponseTo() const + { + static const std::uint8_t cxlRejResponseToValues[] = { 49, 0 }; - return (const char *)cxlRejResponseToValues; - } + return (const char *)cxlRejResponseToValues; + } - SBE_NODISCARD char cxlRejResponseTo(const std::uint64_t index) const { - static const std::uint8_t cxlRejResponseToValues[] = {49}; + SBE_NODISCARD char cxlRejResponseTo(const std::uint64_t index) const + { + static const std::uint8_t cxlRejResponseToValues[] = { 49, 0 }; - return (char)cxlRejResponseToValues[index]; - } + return (char)cxlRejResponseToValues[index]; + } - std::uint64_t - getCxlRejResponseTo(char *dst, const std::uint64_t length) const { - static std::uint8_t cxlRejResponseToValues[] = {49}; - std::uint64_t bytesToCopy = length < sizeof(cxlRejResponseToValues) - ? length - : sizeof(cxlRejResponseToValues); + std::uint64_t getCxlRejResponseTo(char *dst, const std::uint64_t length) const + { + static std::uint8_t cxlRejResponseToValues[] = { 49 }; + std::uint64_t bytesToCopy = length < sizeof(cxlRejResponseToValues) ? length : sizeof(cxlRejResponseToValues); - std::memcpy( - dst, cxlRejResponseToValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, cxlRejResponseToValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getCxlRejResponseToAsString() const { - static const std::uint8_t CxlRejResponseToValues[] = {49}; + std::string getCxlRejResponseToAsString() const + { + static const std::uint8_t CxlRejResponseToValues[] = { 49 }; - return std::string((const char *)CxlRejResponseToValues, 1); - } + return std::string((const char *)CxlRejResponseToValues, 1); + } - std::string getCxlRejResponseToAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCxlRejResponseToAsString(); + std::string getCxlRejResponseToAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCxlRejResponseToAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 356; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 356; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 356, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 356, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReject535 &orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 356, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReject535 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 356, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transactTimeSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 364; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 364; + } - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 364, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 364, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReject535 &transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 364, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReject535 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 364, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 372; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 372; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 372, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 372, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReject535 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 372, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReject535 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 372, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 380; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 380; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 380, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 380, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReject535 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 380, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReject535 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 380, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 388; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 388; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 388; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 388; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 388; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 388; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 388 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 388 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReject535 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + OrderCancelReject535 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 388 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 388 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 388, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 388, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReject535 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 388, src, sizeof(char) * 5); - return *this; - } + OrderCancelReject535 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 388, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 388; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 388; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 388; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 388; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReject535 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReject535 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 388, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 388 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 388, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 388 + start] = 0; + } - return *this; - } -#else - OrderCancelReject535 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + OrderCancelReject535 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 388, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 388 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 388, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 388 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - CxlRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CxlRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cxlRejReasonId() SBE_NOEXCEPT { - return 102; - } + static SBE_CONSTEXPR std::uint16_t cxlRejReasonId() SBE_NOEXCEPT + { + return 102; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cxlRejReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cxlRejReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cxlRejReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cxlRejReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cxlRejReasonSinceVersion(); + return m_actingVersion >= cxlRejReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cxlRejReasonEncodingOffset() SBE_NOEXCEPT { - return 393; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingOffset() SBE_NOEXCEPT + { + return 393; + } - static SBE_CONSTEXPR std::uint16_t cxlRejReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t cxlRejReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t cxlRejReasonMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t cxlRejReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t cxlRejReasonMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t cxlRejReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t cxlRejReason() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 393, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t cxlRejReason() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 393, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - OrderCancelReject535 &cxlRejReason(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 393, &val, sizeof(std::uint16_t)); - return *this; - } + OrderCancelReject535 &cxlRejReason(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 393, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 395; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 395; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 395, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 395, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - OrderCancelReject535 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 395, &val, sizeof(std::uint16_t)); - return *this; - } + OrderCancelReject535 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 395, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 397; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 397; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReject535 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 397, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReject535 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 397, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 398; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 398; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReject535 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 398, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReject535 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 398, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 399; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 399; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReject535 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 399, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReject535 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 399, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 400; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 400; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReject535 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 400, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + OrderCancelReject535 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 400, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 401; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 401; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return 0xffffffffffffffffL; - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return UINT64_C(0xffffffffffffffff); + } - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 401, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 401, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReject535 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 401, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReject535 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 401, &val, sizeof(std::uint64_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - OrderCancelReject535 _writer) { - OrderCancelReject535 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "OrderCancelReject535", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, OrderCancelReject535 _writer) +{ + OrderCancelReject535 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << '{'; + builder << R"("Name": "OrderCancelReject535", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); - builder << ", "; - builder << R"("CxlRejReason": )"; - builder << +writer.cxlRejReason(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); + builder << ", "; + builder << R"("CxlRejReason": )"; + builder << +writer.cxlRejReason(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; - builder << '}'; + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); - return builder; - } + builder << '}'; - void skip() {} + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } +void skip() +{ +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderCancelReplaceReject536.h b/src/lib/orderman/ilink3/generated/OrderCancelReplaceReject536.h index 596c9f79c..0099f7157 100644 --- a/src/lib/orderman/ilink3/generated/OrderCancelReplaceReject536.h +++ b/src/lib/orderman/ilink3/generated/OrderCancelReplaceReject536.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2423 +86,2636 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class OrderCancelReplaceReject536 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class OrderCancelReplaceReject536 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(409); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(536); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - OrderCancelReplaceReject536() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - OrderCancelReplaceReject536( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - OrderCancelReplaceReject536(char *buffer, const std::uint64_t bufferLength) - : OrderCancelReplaceReject536( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + OrderCancelReplaceReject536() = default; - OrderCancelReplaceReject536( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : OrderCancelReplaceReject536( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + OrderCancelReplaceReject536( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)409; - } + OrderCancelReplaceReject536(char *buffer, const std::uint64_t bufferLength) : + OrderCancelReplaceReject536(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + OrderCancelReplaceReject536( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + OrderCancelReplaceReject536(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)536; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(409); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(536); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "9"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - OrderCancelReplaceReject536 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = OrderCancelReplaceReject536( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "9"; + } - OrderCancelReplaceReject536 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + OrderCancelReplaceReject536 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = OrderCancelReplaceReject536(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = OrderCancelReplaceReject536( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + OrderCancelReplaceReject536 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - OrderCancelReplaceReject536 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = OrderCancelReplaceReject536( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = OrderCancelReplaceReject536( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + OrderCancelReplaceReject536 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = OrderCancelReplaceReject536(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + OrderCancelReplaceReject536 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - OrderCancelReplaceReject536 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + OrderCancelReplaceReject536 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderCancelReplaceReject536 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + OrderCancelReplaceReject536 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceReject536 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceReject536 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } + static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT + { + return 58; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= textSinceVersion(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 256; + } - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 256; + } - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReplaceReject536 & - text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } + OrderCancelReplaceReject536 &text(const std::uint64_t index, const char value) + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } + std::uint64_t getText(char *const dst, const std::uint64_t length) const + { + if (length > 256) + { + throw std::runtime_error("length too large for getText [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReplaceReject536 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } + OrderCancelReplaceReject536 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); + return *this; + } - SBE_NODISCARD std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); + std::string getTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTextAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReplaceReject536 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReplaceReject536 &putText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - OrderCancelReplaceReject536 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + return *this; + } + #else + OrderCancelReplaceReject536 &putText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT { return 17; } + static SBE_CONSTEXPR std::uint16_t execIDId() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool execIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execIDSinceVersion(); + return m_actingVersion >= execIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execIDEncodingOffset() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execIDEncodingOffset() SBE_NOEXCEPT + { + return 268; + } - static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char execIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char execIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char execIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT { - return 40; - } + static SBE_CONSTEXPR std::size_t execIDEncodingLength() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint64_t execIDLength() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD const char *execID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD const char *execID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char *execID() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD char *execID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char execID(const std::uint64_t index) const { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E104]"); - } + SBE_NODISCARD char execID(const std::uint64_t index) const + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReplaceReject536 & - execID(const std::uint64_t index, const char value) { - if (index >= 40) { - throw std::runtime_error("index out of range for execID [E105]"); - } + OrderCancelReplaceReject536 &execID(const std::uint64_t index, const char value) + { + if (index >= 40) + { + throw std::runtime_error("index out of range for execID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getExecID(char *const dst, const std::uint64_t length) const { - if (length > 40) { - throw std::runtime_error("length too large for getExecID [E106]"); - } + std::uint64_t getExecID(char *const dst, const std::uint64_t length) const + { + if (length > 40) + { + throw std::runtime_error("length too large for getExecID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReplaceReject536 &putExecID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 40); - return *this; - } + OrderCancelReplaceReject536 &putExecID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 40); + return *this; + } - SBE_NODISCARD std::string getExecIDAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + SBE_NODISCARD std::string getExecIDAsString() const + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getExecIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExecIDAsString(); + std::string getExecIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExecIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExecIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 40 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 40 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReplaceReject536 &putExecID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReplaceReject536 &putExecID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#else - OrderCancelReplaceReject536 &putExecID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 40) { - throw std::runtime_error("string too large for putExecID [E106]"); - } + return *this; + } + #else + OrderCancelReplaceReject536 &putExecID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 40) + { + throw std::runtime_error("string too large for putExecID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 40; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 40; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 308; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 308; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 308; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 308; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 308; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 308; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 308 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 308 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReplaceReject536 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + OrderCancelReplaceReject536 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 308 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 308 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 308, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 308, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReplaceReject536 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 308, src, sizeof(char) * 20); - return *this; - } + OrderCancelReplaceReject536 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 308, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 308; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 308; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 308; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 308; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReplaceReject536 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReplaceReject536 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 308 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 308, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 308 + start] = 0; + } - return *this; - } -#else - OrderCancelReplaceReject536 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + OrderCancelReplaceReject536 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 308 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 308, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 308 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 328; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 328; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 328; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 328; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 328; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 328; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 328 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 328 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReplaceReject536 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + OrderCancelReplaceReject536 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 328 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 328 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 328, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 328, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReplaceReject536 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 328, src, sizeof(char) * 20); - return *this; - } + OrderCancelReplaceReject536 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 328, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 328; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 328; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 328; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 328; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReplaceReject536 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReplaceReject536 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 328 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 328, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 328 + start] = 0; + } - return *this; - } -#else - OrderCancelReplaceReject536 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + OrderCancelReplaceReject536 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 328 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 328, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 328 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 348; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 348; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceReject536 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceReject536 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 356; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 356; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 356, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 356, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceReject536 & - orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 356, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceReject536 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 356, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transactTimeSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 364; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 364; + } - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 364, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 364, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceReject536 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 364, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceReject536 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 364, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 372; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 372; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 372, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 372, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceReject536 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 372, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceReject536 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 372, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 380; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 380; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 380, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 380, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceReject536 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 380, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceReject536 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 380, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 388; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 388; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 388; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 388; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 388; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 388; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 388 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 388 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReplaceReject536 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + OrderCancelReplaceReject536 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 388 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 388 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 388, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 388, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReplaceReject536 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 388, src, sizeof(char) * 5); - return *this; - } + OrderCancelReplaceReject536 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 388, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 388; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 388; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 388; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 388; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReplaceReject536 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReplaceReject536 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 388, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 388 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 388, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 388 + start] = 0; + } - return *this; - } -#else - OrderCancelReplaceReject536 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + OrderCancelReplaceReject536 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 388, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 388 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 388, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 388 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - CxlRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CxlRejReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cxlRejReasonId() SBE_NOEXCEPT { - return 102; - } + static SBE_CONSTEXPR std::uint16_t cxlRejReasonId() SBE_NOEXCEPT + { + return 102; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cxlRejReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cxlRejReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cxlRejReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cxlRejReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cxlRejReasonSinceVersion(); + return m_actingVersion >= cxlRejReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cxlRejReasonEncodingOffset() SBE_NOEXCEPT { - return 393; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingOffset() SBE_NOEXCEPT + { + return 393; + } - static SBE_CONSTEXPR std::uint16_t cxlRejReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t cxlRejReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t cxlRejReasonMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t cxlRejReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t cxlRejReasonMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t cxlRejReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t cxlRejReasonEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t cxlRejReason() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 393, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t cxlRejReason() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 393, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - OrderCancelReplaceReject536 & - cxlRejReason(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 393, &val, sizeof(std::uint16_t)); - return *this; - } + OrderCancelReplaceReject536 &cxlRejReason(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 393, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 395; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 395; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 395, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 395, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - OrderCancelReplaceReject536 & - delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 395, &val, sizeof(std::uint16_t)); - return *this; - } + OrderCancelReplaceReject536 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 395, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT { return 39; } + static SBE_CONSTEXPR std::uint16_t ordStatusId() SBE_NOEXCEPT + { + return 39; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusSinceVersion(); + return m_actingVersion >= ordStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusEncodingOffset() SBE_NOEXCEPT { - return 397; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusEncodingOffset() SBE_NOEXCEPT + { + return 397; + } - static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char ordStatusNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char ordStatusMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char ordStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t ordStatusEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t ordStatusLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *ordStatus() const { - static const std::uint8_t ordStatusValues[] = {85}; + SBE_NODISCARD const char *ordStatus() const + { + static const std::uint8_t ordStatusValues[] = { 85, 0 }; - return (const char *)ordStatusValues; - } + return (const char *)ordStatusValues; + } - SBE_NODISCARD char ordStatus(const std::uint64_t index) const { - static const std::uint8_t ordStatusValues[] = {85}; + SBE_NODISCARD char ordStatus(const std::uint64_t index) const + { + static const std::uint8_t ordStatusValues[] = { 85, 0 }; - return (char)ordStatusValues[index]; - } + return (char)ordStatusValues[index]; + } - std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const { - static std::uint8_t ordStatusValues[] = {85}; - std::uint64_t bytesToCopy = - length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); + std::uint64_t getOrdStatus(char *dst, const std::uint64_t length) const + { + static std::uint8_t ordStatusValues[] = { 85 }; + std::uint64_t bytesToCopy = length < sizeof(ordStatusValues) ? length : sizeof(ordStatusValues); - std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, ordStatusValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getOrdStatusAsString() const { - static const std::uint8_t OrdStatusValues[] = {85}; + std::string getOrdStatusAsString() const + { + static const std::uint8_t OrdStatusValues[] = { 85 }; - return std::string((const char *)OrdStatusValues, 1); - } + return std::string((const char *)OrdStatusValues, 1); + } - std::string getOrdStatusAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrdStatusAsString(); + std::string getOrdStatusAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrdStatusAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char *CxlRejResponseToMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CxlRejResponseToMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cxlRejResponseToId() SBE_NOEXCEPT { - return 434; - } + static SBE_CONSTEXPR std::uint16_t cxlRejResponseToId() SBE_NOEXCEPT + { + return 434; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cxlRejResponseToSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cxlRejResponseToSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cxlRejResponseToInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cxlRejResponseToInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cxlRejResponseToSinceVersion(); + return m_actingVersion >= cxlRejResponseToSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cxlRejResponseToEncodingOffset() SBE_NOEXCEPT { - return 397; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingOffset() SBE_NOEXCEPT + { + return 397; + } - static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char cxlRejResponseToNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char cxlRejResponseToMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char cxlRejResponseToMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - cxlRejResponseToEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t cxlRejResponseToEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t cxlRejResponseToLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t cxlRejResponseToLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *cxlRejResponseTo() const { - static const std::uint8_t cxlRejResponseToValues[] = {50}; + SBE_NODISCARD const char *cxlRejResponseTo() const + { + static const std::uint8_t cxlRejResponseToValues[] = { 50, 0 }; - return (const char *)cxlRejResponseToValues; - } + return (const char *)cxlRejResponseToValues; + } - SBE_NODISCARD char cxlRejResponseTo(const std::uint64_t index) const { - static const std::uint8_t cxlRejResponseToValues[] = {50}; + SBE_NODISCARD char cxlRejResponseTo(const std::uint64_t index) const + { + static const std::uint8_t cxlRejResponseToValues[] = { 50, 0 }; - return (char)cxlRejResponseToValues[index]; - } + return (char)cxlRejResponseToValues[index]; + } - std::uint64_t - getCxlRejResponseTo(char *dst, const std::uint64_t length) const { - static std::uint8_t cxlRejResponseToValues[] = {50}; - std::uint64_t bytesToCopy = length < sizeof(cxlRejResponseToValues) - ? length - : sizeof(cxlRejResponseToValues); + std::uint64_t getCxlRejResponseTo(char *dst, const std::uint64_t length) const + { + static std::uint8_t cxlRejResponseToValues[] = { 50 }; + std::uint64_t bytesToCopy = length < sizeof(cxlRejResponseToValues) ? length : sizeof(cxlRejResponseToValues); - std::memcpy( - dst, cxlRejResponseToValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, cxlRejResponseToValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getCxlRejResponseToAsString() const { - static const std::uint8_t CxlRejResponseToValues[] = {50}; + std::string getCxlRejResponseToAsString() const + { + static const std::uint8_t CxlRejResponseToValues[] = { 50 }; - return std::string((const char *)CxlRejResponseToValues, 1); - } + return std::string((const char *)CxlRejResponseToValues, 1); + } - std::string getCxlRejResponseToAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCxlRejResponseToAsString(); + std::string getCxlRejResponseToAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCxlRejResponseToAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 397; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 397; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceReject536 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 397, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 397, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceReject536 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 397, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 398; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 398; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceReject536 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 398, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 398, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceReject536 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 398, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 399; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 399; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceReject536 & - splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 399, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 399, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceReject536 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 399, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 400; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 400; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceReject536 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 400, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 400, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + OrderCancelReplaceReject536 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 400, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 401; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 401; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return 0xffffffffffffffffL; - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return UINT64_C(0xffffffffffffffff); + } - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 401, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 401, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceReject536 & - delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 401, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceReject536 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 401, &val, sizeof(std::uint64_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - OrderCancelReplaceReject536 _writer) { - OrderCancelReplaceReject536 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "OrderCancelReplaceReject536", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, OrderCancelReplaceReject536 _writer) +{ + OrderCancelReplaceReject536 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << '{'; + builder << R"("Name": "OrderCancelReplaceReject536", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("ExecID": )"; - builder << '"' << writer.getExecIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("ExecID": )"; + builder << '"' << + writer.getExecIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); - builder << ", "; - builder << R"("CxlRejReason": )"; - builder << +writer.cxlRejReason(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); + builder << ", "; + builder << R"("CxlRejReason": )"; + builder << +writer.cxlRejReason(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; - builder << '}'; + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); - return builder; - } + builder << '}'; - void skip() {} + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } +void skip() +{ +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderCancelReplaceRequest515.h b/src/lib/orderman/ilink3/generated/OrderCancelReplaceRequest515.h index c323ecf10..e5b252850 100644 --- a/src/lib/orderman/ilink3/generated/OrderCancelReplaceRequest515.h +++ b/src/lib/orderman/ilink3/generated/OrderCancelReplaceRequest515.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2227 +86,2510 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class OrderCancelReplaceRequest515 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class OrderCancelReplaceRequest515 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(133); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(515); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - OrderCancelReplaceRequest515() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - OrderCancelReplaceRequest515( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - OrderCancelReplaceRequest515(char *buffer, const std::uint64_t bufferLength) - : OrderCancelReplaceRequest515( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + OrderCancelReplaceRequest515() = default; - OrderCancelReplaceRequest515( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : OrderCancelReplaceRequest515( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + OrderCancelReplaceRequest515( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)125; - } + OrderCancelReplaceRequest515(char *buffer, const std::uint64_t bufferLength) : + OrderCancelReplaceRequest515(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + OrderCancelReplaceRequest515( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + OrderCancelReplaceRequest515(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)515; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(133); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(515); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "G"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - OrderCancelReplaceRequest515 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = OrderCancelReplaceRequest515( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "G"; + } - OrderCancelReplaceRequest515 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + OrderCancelReplaceRequest515 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = OrderCancelReplaceRequest515(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = OrderCancelReplaceRequest515( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + OrderCancelReplaceRequest515 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - OrderCancelReplaceRequest515 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = OrderCancelReplaceRequest515( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = OrderCancelReplaceRequest515( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + OrderCancelReplaceRequest515 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = OrderCancelReplaceRequest515(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + OrderCancelReplaceRequest515 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - OrderCancelReplaceRequest515 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + OrderCancelReplaceRequest515 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT { return 44; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t priceId() SBE_NOEXCEPT + { + return 44; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool priceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceSinceVersion(); + return m_actingVersion >= priceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICENULL9 m_price; +private: + PRICENULL9 m_price; - public: - SBE_NODISCARD PRICENULL9 &price() { - m_price.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_price; - } +public: + SBE_NODISCARD PRICENULL9 &price() + { + m_price.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_price; + } - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { return 38; } + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderQtySinceVersion(); + return m_actingVersion >= orderQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderCancelReplaceRequest515 & - orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + OrderCancelReplaceRequest515 &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderCancelReplaceRequest515 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 12, &val, sizeof(std::int32_t)); - return *this; - } + OrderCancelReplaceRequest515 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 12, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceRequest515 &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceRequest515 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderCancelReplaceRequest515 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + OrderCancelReplaceRequest515 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReplaceRequest515 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + OrderCancelReplaceRequest515 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReplaceRequest515 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + OrderCancelReplaceRequest515 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReplaceRequest515 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReplaceRequest515 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - OrderCancelReplaceRequest515 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + OrderCancelReplaceRequest515 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 41; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 41; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 41; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 41; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 41 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 41 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReplaceRequest515 & - clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + OrderCancelReplaceRequest515 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 41 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 41 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 41, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReplaceRequest515 & - putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 41, src, sizeof(char) * 20); - return *this; - } + OrderCancelReplaceRequest515 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 41, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 41; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 41; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 41; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 41; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReplaceRequest515 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReplaceRequest515 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 41 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 41 + start] = 0; + } - return *this; - } -#else - OrderCancelReplaceRequest515 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + OrderCancelReplaceRequest515 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 41 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 41 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 61; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 61; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceRequest515 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceRequest515 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 69; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 69; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceRequest515 & - orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceRequest515 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StopPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT { return 99; } + static SBE_CONSTEXPR std::uint16_t stopPxId() SBE_NOEXCEPT + { + return 99; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - stopPxSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t stopPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool stopPxInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= stopPxSinceVersion(); + return m_actingVersion >= stopPxSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - stopPxEncodingOffset() SBE_NOEXCEPT { - return 77; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t stopPxEncodingOffset() SBE_NOEXCEPT + { + return 77; + } - private: - PRICENULL9 m_stopPx; +private: + PRICENULL9 m_stopPx; - public: - SBE_NODISCARD PRICENULL9 &stopPx() { - m_stopPx.wrap(m_buffer, m_offset + 77, m_actingVersion, m_bufferLength); - return m_stopPx; - } +public: + SBE_NODISCARD PRICENULL9 &stopPx() + { + m_stopPx.wrap(m_buffer, m_offset + 77, m_actingVersion, m_bufferLength); + return m_stopPx; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 85; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 85; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 85, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 85, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceRequest515 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 85, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceRequest515 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 85, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 93; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 93; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 93, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 93, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelReplaceRequest515 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 93, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelReplaceRequest515 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 93, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 101; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 101; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 101; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 101; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 101; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 101; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 101 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 101 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelReplaceRequest515 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + OrderCancelReplaceRequest515 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 101 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 101 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 101, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 101, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelReplaceRequest515 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 101, src, sizeof(char) * 5); - return *this; - } + OrderCancelReplaceRequest515 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 101, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 101; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 101; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 101; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 101; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelReplaceRequest515 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelReplaceRequest515 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 101, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 101 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 101, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 101 + start] = 0; + } - return *this; - } -#else - OrderCancelReplaceRequest515 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + OrderCancelReplaceRequest515 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 101, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 101 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 101, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 101 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT { return 110; } + static SBE_CONSTEXPR std::uint16_t minQtyId() SBE_NOEXCEPT + { + return 110; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minQtySinceVersion(); + return m_actingVersion >= minQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minQtyEncodingOffset() SBE_NOEXCEPT { - return 106; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minQtyEncodingOffset() SBE_NOEXCEPT + { + return 106; + } - static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t minQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 106, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 106, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderCancelReplaceRequest515 & - minQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 106, &val, sizeof(std::uint32_t)); - return *this; - } + OrderCancelReplaceRequest515 &minQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 106, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT { - return 1138; - } + static SBE_CONSTEXPR std::uint16_t displayQtyId() SBE_NOEXCEPT + { + return 1138; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayQtySinceVersion(); + return m_actingVersion >= displayQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayQtyEncodingOffset() SBE_NOEXCEPT { - return 110; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayQtyEncodingOffset() SBE_NOEXCEPT + { + return 110; + } - static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t displayQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t displayQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t displayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t displayQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderCancelReplaceRequest515 & - displayQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint32_t)); - return *this; - } + OrderCancelReplaceRequest515 &displayQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExpireDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT { - return 432; - } + static SBE_CONSTEXPR std::uint16_t expireDateId() SBE_NOEXCEPT + { + return 432; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expireDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expireDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool expireDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= expireDateSinceVersion(); + return m_actingVersion >= expireDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expireDateEncodingOffset() SBE_NOEXCEPT { - return 114; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expireDateEncodingOffset() SBE_NOEXCEPT + { + return 114; + } - static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t expireDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t expireDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t expireDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t expireDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 114, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t expireDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 114, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - OrderCancelReplaceRequest515 & - expireDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 114, &val, sizeof(std::uint16_t)); - return *this; - } + OrderCancelReplaceRequest515 &expireDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 114, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 116; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 116; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OrderTypeReq::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 116, sizeof(char)); - return OrderTypeReq::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 116, sizeof(char)); + return (val); + } - OrderCancelReplaceRequest515 & - ordType(const OrderTypeReq::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 116, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD OrderTypeReq::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 116, sizeof(char)); + return OrderTypeReq::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceRequest515 &ordType(const OrderTypeReq::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 116, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 117; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 117; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD TimeInForce::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 117, sizeof(std::uint8_t)); - return TimeInForce::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 117, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceRequest515 & - timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 117, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD TimeInForce::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 117, sizeof(std::uint8_t)); + return TimeInForce::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceRequest515 &timeInForce(const TimeInForce::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 117, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 118; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 118; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 118, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 118, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceRequest515 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 118, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 118, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - OFMOverrideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceRequest515 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 118, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t oFMOverrideId() SBE_NOEXCEPT { - return 9768; - } + SBE_NODISCARD static const char *OFMOverrideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - oFMOverrideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t oFMOverrideId() SBE_NOEXCEPT + { + return 9768; + } - SBE_NODISCARD bool oFMOverrideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t oFMOverrideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool oFMOverrideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= oFMOverrideSinceVersion(); + return m_actingVersion >= oFMOverrideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - oFMOverrideEncodingOffset() SBE_NOEXCEPT { - return 119; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t oFMOverrideEncodingOffset() SBE_NOEXCEPT + { + return 119; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - oFMOverrideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t oFMOverrideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD OFMOverrideReq::Value oFMOverride() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::uint8_t)); - return OFMOverrideReq::get((val)); - } + SBE_NODISCARD std::uint8_t oFMOverrideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceRequest515 & - oFMOverride(const OFMOverrideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 119, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD OFMOverrideReq::Value oFMOverride() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::uint8_t)); + return OFMOverrideReq::get((val)); + } - SBE_NODISCARD static const char * - ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceRequest515 &oFMOverride(const OFMOverrideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 119, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT { return 18; } + SBE_NODISCARD static const char *ExecInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MultipleCharValue"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - execInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t execInstId() SBE_NOEXCEPT + { + return 18; + } - SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t execInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool execInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= execInstSinceVersion(); + return m_actingVersion >= execInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - execInstEncodingOffset() SBE_NOEXCEPT { - return 120; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t execInstEncodingOffset() SBE_NOEXCEPT + { + return 120; + } - private: - ExecInst m_execInst; +private: + ExecInst m_execInst; - public: - SBE_NODISCARD ExecInst &execInst() { - m_execInst.wrap( - m_buffer, m_offset + 120, m_actingVersion, m_bufferLength); - return m_execInst; - } +public: + SBE_NODISCARD ExecInst &execInst() + { + m_execInst.wrap(m_buffer, m_offset + 120, m_actingVersion, m_bufferLength); + return m_execInst; + } - static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t execInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecutionModeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT { - return 5906; - } + static SBE_CONSTEXPR std::uint16_t executionModeId() SBE_NOEXCEPT + { + return 5906; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executionModeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executionModeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool executionModeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executionModeSinceVersion(); + return m_actingVersion >= executionModeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingOffset() SBE_NOEXCEPT { - return 121; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingOffset() SBE_NOEXCEPT + { + return 121; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executionModeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executionModeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ExecMode::Value executionMode() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 121, sizeof(char)); - return ExecMode::get((val)); - } + SBE_NODISCARD char executionModeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 121, sizeof(char)); + return (val); + } - OrderCancelReplaceRequest515 & - executionMode(const ExecMode::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 121, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ExecMode::Value executionMode() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 121, sizeof(char)); + return ExecMode::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceRequest515 &executionMode(const ExecMode::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 121, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 122; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 122; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 122, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 122, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceRequest515 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 122, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 122, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceRequest515 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 122, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT { - return 6881; - } + SBE_NODISCARD static const char *ManagedOrderMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - managedOrderSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t managedOrderId() SBE_NOEXCEPT + { + return 6881; + } - SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t managedOrderSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool managedOrderInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= managedOrderSinceVersion(); + return m_actingVersion >= managedOrderSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingOffset() SBE_NOEXCEPT { - return 123; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingOffset() SBE_NOEXCEPT + { + return 123; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - managedOrderEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t managedOrderEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value managedOrder() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 123, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t managedOrderRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 123, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceRequest515 & - managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 123, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value managedOrder() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 123, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char * - ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelReplaceRequest515 &managedOrder(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 123, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT { - return 5409; - } + SBE_NODISCARD static const char *ShortSaleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - shortSaleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t shortSaleTypeId() SBE_NOEXCEPT + { + return 5409; + } - SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t shortSaleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool shortSaleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= shortSaleTypeSinceVersion(); + return m_actingVersion >= shortSaleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingOffset() SBE_NOEXCEPT { - return 124; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingOffset() SBE_NOEXCEPT + { + return 124; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - shortSaleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t shortSaleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ShortSaleType::Value shortSaleType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint8_t)); - return ShortSaleType::get((val)); - } + SBE_NODISCARD std::uint8_t shortSaleTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint8_t)); + return (val); + } - OrderCancelReplaceRequest515 & - shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ShortSaleType::Value shortSaleType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(std::uint8_t)); + return ShortSaleType::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - OrderCancelReplaceRequest515 _writer) { - OrderCancelReplaceRequest515 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "OrderCancelReplaceRequest515", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + OrderCancelReplaceRequest515 &shortSaleType(const ShortSaleType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("Price": )"; - builder << writer.price(); + SBE_NODISCARD static const char *DiscretionPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); + static SBE_CONSTEXPR std::uint16_t discretionPriceId() SBE_NOEXCEPT + { + return 845; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t discretionPriceSinceVersion() SBE_NOEXCEPT + { + return 6; + } - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + SBE_NODISCARD bool discretionPriceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= discretionPriceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t discretionPriceEncodingOffset() SBE_NOEXCEPT + { + return 125; + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; +private: + PRICENULL9 m_discretionPrice; - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; +public: + SBE_NODISCARD PRICENULL9 &discretionPrice() + { + m_discretionPrice.wrap(m_buffer, m_offset + 125, m_actingVersion, m_bufferLength); + return m_discretionPrice; + } - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, OrderCancelReplaceRequest515 _writer) +{ + OrderCancelReplaceRequest515 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + builder << '{'; + builder << R"("Name": "OrderCancelReplaceRequest515", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("StopPx": )"; - builder << writer.stopPx(); + builder << R"("Price": )"; + builder << writer.price(); - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; - builder << ", "; - builder << R"("MinQty": )"; - builder << +writer.minQty(); + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("DisplayQty": )"; - builder << +writer.displayQty(); + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ExpireDate": )"; - builder << +writer.expireDate(); + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("StopPx": )"; + builder << writer.stopPx(); - builder << ", "; - builder << R"("OFMOverride": )"; - builder << '"' << writer.oFMOverride() << '"'; + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); - builder << ", "; - builder << R"("ExecInst": )"; - builder << writer.execInst(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("ExecutionMode": )"; - builder << '"' << writer.executionMode() << '"'; + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("MinQty": )"; + builder << +writer.minQty(); - builder << ", "; - builder << R"("ManagedOrder": )"; - builder << '"' << writer.managedOrder() << '"'; + builder << ", "; + builder << R"("DisplayQty": )"; + builder << +writer.displayQty(); - builder << ", "; - builder << R"("ShortSaleType": )"; - builder << '"' << writer.shortSaleType() << '"'; + builder << ", "; + builder << R"("ExpireDate": )"; + builder << +writer.expireDate(); - builder << '}'; + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; - return builder; - } + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; - void skip() {} + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + builder << ", "; + builder << R"("OFMOverride": )"; + builder << '"' << writer.oFMOverride() << '"'; - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + builder << ", "; + builder << R"("ExecInst": )"; + builder << writer.execInst(); + + builder << ", "; + builder << R"("ExecutionMode": )"; + builder << '"' << writer.executionMode() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("ManagedOrder": )"; + builder << '"' << writer.managedOrder() << '"'; + + builder << ", "; + builder << R"("ShortSaleType": )"; + builder << '"' << writer.shortSaleType() << '"'; + + builder << ", "; + builder << R"("DiscretionPrice": )"; + if (writer.discretionPriceInActingVersion()) + { + builder << writer.discretionPrice(); + } + else + { + builder << "{}"; + } + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderCancelRequest516.h b/src/lib/orderman/ilink3/generated/OrderCancelRequest516.h index 3475e5439..9d0f356e4 100644 --- a/src/lib/orderman/ilink3/generated/OrderCancelRequest516.h +++ b/src/lib/orderman/ilink3/generated/OrderCancelRequest516.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1443 +86,1828 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class OrderCancelRequest516 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class OrderCancelRequest516 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(96); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(516); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - OrderCancelRequest516() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - OrderCancelRequest516( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - OrderCancelRequest516(char *buffer, const std::uint64_t bufferLength) - : OrderCancelRequest516( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + OrderCancelRequest516() = default; - OrderCancelRequest516( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : OrderCancelRequest516( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + OrderCancelRequest516( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)88; - } + OrderCancelRequest516(char *buffer, const std::uint64_t bufferLength) : + OrderCancelRequest516(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + OrderCancelRequest516( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + OrderCancelRequest516(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)516; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(96); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(516); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "F"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - OrderCancelRequest516 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = OrderCancelRequest516( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "F"; + } - OrderCancelRequest516 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + OrderCancelRequest516 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = OrderCancelRequest516(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = OrderCancelRequest516( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + OrderCancelRequest516 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - OrderCancelRequest516 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = OrderCancelRequest516( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = OrderCancelRequest516( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + OrderCancelRequest516 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = OrderCancelRequest516(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + OrderCancelRequest516 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - OrderCancelRequest516 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + OrderCancelRequest516 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelRequest516 &orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelRequest516 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelRequest516 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelRequest516 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - OrderCancelRequest516 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelRequest516 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderCancelRequest516 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + OrderCancelRequest516 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelRequest516 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + OrderCancelRequest516 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelRequest516 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + OrderCancelRequest516 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelRequest516 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelRequest516 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - OrderCancelRequest516 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + OrderCancelRequest516 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT { return 11; } + static SBE_CONSTEXPR std::uint16_t clOrdIDId() SBE_NOEXCEPT + { + return 11; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clOrdIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clOrdIDSinceVersion(); + return m_actingVersion >= clOrdIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clOrdIDEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char clOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char clOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char clOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t clOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t clOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 41; - } + SBE_NODISCARD const char *clOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 41; + } - SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 41; - } + SBE_NODISCARD char *clOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 41; + } - SBE_NODISCARD char clOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E104]"); - } + SBE_NODISCARD char clOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 41 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 41 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelRequest516 &clOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for clOrdID [E105]"); - } + OrderCancelRequest516 &clOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for clOrdID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 41 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 41 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getClOrdID [E106]"); - } + std::uint64_t getClOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getClOrdID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 41, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelRequest516 &putClOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 41, src, sizeof(char) * 20); - return *this; - } + OrderCancelRequest516 &putClOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 41, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getClOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 41; - size_t length = 0; + SBE_NODISCARD std::string getClOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 41; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getClOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getClOrdIDAsString(); + std::string getClOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getClOrdIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 41; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getClOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 41; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelRequest516 &putClOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelRequest516 &putClOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 41 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 41 + start] = 0; + } - return *this; - } -#else - OrderCancelRequest516 &putClOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putClOrdID [E106]"); - } + return *this; + } + #else + OrderCancelRequest516 &putClOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putClOrdID [E106]"); + } - std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 41 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 41 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 61; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 61; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 61, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelRequest516 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelRequest516 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 61, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 69; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 69; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderCancelRequest516 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint64_t)); - return *this; - } + OrderCancelRequest516 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 77; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 77; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 77; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 77; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 77; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 77; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 77 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 77 + (index * 1), sizeof(char)); + return (val); + } - OrderCancelRequest516 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + OrderCancelRequest516 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 77 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 77 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 77, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 77, sizeof(char) * static_cast(length)); + return length; + } - OrderCancelRequest516 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 77, src, sizeof(char) * 5); - return *this; - } + OrderCancelRequest516 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 77, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 77; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 77; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 77; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 77; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderCancelRequest516 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + OrderCancelRequest516 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 77, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 77 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 77, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 77 + start] = 0; + } - return *this; - } -#else - OrderCancelRequest516 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + OrderCancelRequest516 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 77, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 77 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 77, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 77 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 82; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 82; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 82, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 82, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderCancelRequest516 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 82, &val, sizeof(std::int32_t)); - return *this; - } + OrderCancelRequest516 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 82, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 86; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 86; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideReq::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint8_t)); + return (val); + } - OrderCancelRequest516 &side(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 86, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideReq::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint8_t)); + return SideReq::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderCancelRequest516 &side(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 86, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 87; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 87; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint8_t)); + return (val); + } - OrderCancelRequest516 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - OrderCancelRequest516 _writer) { - OrderCancelRequest516 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "OrderCancelRequest516", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + OrderCancelRequest516 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("OrderID": )"; - builder << +writer.orderID(); + SBE_NODISCARD static const char *OrigOrderUserMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + static SBE_CONSTEXPR std::uint16_t origOrderUserId() SBE_NOEXCEPT + { + return 9937; + } - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origOrderUserSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + SBE_NODISCARD bool origOrderUserInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origOrderUserSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origOrderUserEncodingOffset() SBE_NOEXCEPT + { + return 88; + } - builder << ", "; - builder << R"("ClOrdID": )"; - builder << '"' << writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + static SBE_CONSTEXPR char origOrderUserNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + static SBE_CONSTEXPR char origOrderUserMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + static SBE_CONSTEXPR char origOrderUserMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + static SBE_CONSTEXPR std::size_t origOrderUserEncodingLength() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + static SBE_CONSTEXPR std::uint64_t origOrderUserLength() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + SBE_NODISCARD const char *origOrderUser() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + return m_buffer + m_offset + 88; + } - builder << '}'; + SBE_NODISCARD char *origOrderUser() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } - return builder; - } + return m_buffer + m_offset + 88; + } - void skip() {} + SBE_NODISCARD char origOrderUser(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E104]"); + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + if (m_actingVersion < 8) + { + return static_cast(0); + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + char val; + std::memcpy(&val, m_buffer + m_offset + 88 + (index * 1), sizeof(char)); + return (val); + } + + OrderCancelRequest516 &origOrderUser(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 88 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrigOrderUser(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getOrigOrderUser [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 88, sizeof(char) * static_cast(length)); + return length; + } + + OrderCancelRequest516 &putOrigOrderUser(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 88, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getOrigOrderUserAsString() const + { + const char *buffer = m_buffer + m_offset + 88; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrigOrderUserAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrigOrderUserAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrigOrderUserAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 88; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + OrderCancelRequest516 &putOrigOrderUser(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 88, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 88 + start] = 0; + } + + return *this; + } + #else + OrderCancelRequest516 &putOrigOrderUser(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 88, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 88 + start] = 0; + } + + return *this; + } + #endif + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, OrderCancelRequest516 _writer) +{ + OrderCancelRequest516 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "OrderCancelRequest516", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("ClOrdID": )"; + builder << '"' << + writer.getClOrdIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("OrigOrderUser": )"; + builder << '"' << + writer.getOrigOrderUserAsJsonEscapedString().c_str() << '"'; + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderEventType.h b/src/lib/orderman/ilink3/generated/OrderEventType.h index b7e08f553..acd99c1a6 100644 --- a/src/lib/orderman/ilink3/generated/OrderEventType.h +++ b/src/lib/orderman/ilink3/generated/OrderEventType.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_ORDEREVENTTYPE_H_ #define _ILINKBINARY_ORDEREVENTTYPE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class OrderEventType { - public: - enum Value { - PartiallyFilled = (std::uint8_t)4, - Filled = (std::uint8_t)5, - NULL_VALUE = (std::uint8_t)255 - }; +class OrderEventType +{ +public: + enum Value + { + PartiallyFilled = static_cast(4), + Filled = static_cast(5), + NULL_VALUE = static_cast(255) + }; - static OrderEventType::Value get(const std::uint8_t value) { - switch (value) { - case 4: - return PartiallyFilled; - case 5: - return Filled; - case 255: - return NULL_VALUE; - } + static OrderEventType::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(4): return PartiallyFilled; + case static_cast(5): return Filled; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum OrderEventType [E103]"); - } + throw std::runtime_error("unknown value for enum OrderEventType [E103]"); + } - static const char *c_str(const OrderEventType::Value value) { - switch (value) { - case PartiallyFilled: - return "PartiallyFilled"; - case Filled: - return "Filled"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const OrderEventType::Value value) + { + switch (value) + { + case PartiallyFilled: return "PartiallyFilled"; + case Filled: return "Filled"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum OrderEventType [E103]:"); - } + throw std::runtime_error("unknown value for enum OrderEventType [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, OrderEventType::Value m) { - return os << OrderEventType::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, OrderEventType::Value m) + { + return os << OrderEventType::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderMassActionReport558.h b/src/lib/orderman/ilink3/generated/OrderMassActionReport558.h deleted file mode 100644 index f044d6982..000000000 --- a/src/lib/orderman/ilink3/generated/OrderMassActionReport558.h +++ /dev/null @@ -1,3202 +0,0 @@ -/* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERMASSACTIONREPORT558_H_ -#define _ILINKBINARY_ORDERMASSACTIONREPORT558_H_ - -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#include -#include -#include -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201703L -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - -#if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 -#endif -#include -#include -#include -#include - -#include -#include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif - -#define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() -#define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() -#define SBE_NULLVALUE_INT32 (std::numeric_limits::min)() -#define SBE_NULLVALUE_INT64 (std::numeric_limits::min)() -#define SBE_NULLVALUE_UINT8 (std::numeric_limits::max)() -#define SBE_NULLVALUE_UINT16 (std::numeric_limits::max)() -#define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() -#define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() - -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" -#include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" -#include "OrderTypeReq.h" -#include "PRICE9.h" -#include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" -#include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" -#include "TimeInForce.h" -#include "TradeAddendum.h" - -namespace iLinkBinary { - -class OrderMassActionReport558 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - OrderMassActionReport558() = default; - - OrderMassActionReport558( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - OrderMassActionReport558(char *buffer, const std::uint64_t bufferLength) - : OrderMassActionReport558( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - OrderMassActionReport558( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : OrderMassActionReport558( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)103; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)558; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)2; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "BZ"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - OrderMassActionReport558 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = OrderMassActionReport558( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - OrderMassActionReport558 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = OrderMassActionReport558( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - OrderMassActionReport558 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = OrderMassActionReport558( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - OrderMassActionReport558 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= uUIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - OrderMassActionReport558 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } - - OrderMassActionReport558 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } - - OrderMassActionReport558 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 20); - return *this; - } - - std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (auto c = s.cbegin(); c != s.cend(); c++) { - switch (*c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - OrderMassActionReport558 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#else - OrderMassActionReport558 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - OrderMassActionReport558 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= transactTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 40; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 40, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - OrderMassActionReport558 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 40, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 48; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - OrderMassActionReport558 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderRequestIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 56; - } - - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - OrderMassActionReport558 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *MassActionReportIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t massActionReportIDId() SBE_NOEXCEPT { - return 1369; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionReportIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool massActionReportIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= massActionReportIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionReportIDEncodingOffset() SBE_NOEXCEPT { - return 64; - } - - static SBE_CONSTEXPR std::uint64_t - massActionReportIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - massActionReportIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - massActionReportIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - massActionReportIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t massActionReportID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - OrderMassActionReport558 & - massActionReportID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - MassActionTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t massActionTypeId() SBE_NOEXCEPT { - return 1373; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool massActionTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= massActionTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionTypeEncodingOffset() SBE_NOEXCEPT { - return 72; - } - - static SBE_CONSTEXPR char massActionTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char massActionTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char massActionTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - massActionTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t massActionTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *massActionType() const { - static const std::uint8_t massActionTypeValues[] = {51}; - - return (const char *)massActionTypeValues; - } - - SBE_NODISCARD char massActionType(const std::uint64_t index) const { - static const std::uint8_t massActionTypeValues[] = {51}; - - return (char)massActionTypeValues[index]; - } - - std::uint64_t - getMassActionType(char *dst, const std::uint64_t length) const { - static std::uint8_t massActionTypeValues[] = {51}; - std::uint64_t bytesToCopy = length < sizeof(massActionTypeValues) - ? length - : sizeof(massActionTypeValues); - - std::memcpy(dst, massActionTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getMassActionTypeAsString() const { - static const std::uint8_t MassActionTypeValues[] = {51}; - - return std::string((const char *)MassActionTypeValues, 1); - } - - std::string getMassActionTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMassActionTypeAsString(); - - for (auto c = s.cbegin(); c != s.cend(); c++) { - switch (*c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char * - SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT { - return 1151; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityGroupSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityGroupSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityGroupEncodingOffset() SBE_NOEXCEPT { - return 72; - } - - static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT { - return 6; - } - - static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT { - return 6; - } - - SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } - - SBE_NODISCARD char securityGroup(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } - - OrderMassActionReport558 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSecurityGroup(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error( - "length too large for getSecurityGroup [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } - - OrderMassActionReport558 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 6); - return *this; - } - - std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSecurityGroupAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityGroupAsString(); - - for (auto c = s.cbegin(); c != s.cend(); c++) { - switch (*c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; - - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - OrderMassActionReport558 &putSecurityGroup(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#else - OrderMassActionReport558 &putSecurityGroup(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } - - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 78; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 78; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 78; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 78 + (index * 1), sizeof(char)); - return (val); - } - - OrderMassActionReport558 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 78 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 78, - sizeof(char) * static_cast(length)); - return length; - } - - OrderMassActionReport558 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 78, src, sizeof(char) * 5); - return *this; - } - - std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 78; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (auto c = s.cbegin(); c != s.cend(); c++) { - switch (*c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 78; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - OrderMassActionReport558 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 78, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 78 + start] = 0; - } - - return *this; - } -#else - OrderMassActionReport558 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 78, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 78 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 83; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 83, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - OrderMassActionReport558 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 83, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= delayDurationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 87; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - OrderMassActionReport558 & - delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char *MassActionResponseMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t massActionResponseId() SBE_NOEXCEPT { - return 1375; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionResponseSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool massActionResponseInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= massActionResponseSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionResponseEncodingOffset() SBE_NOEXCEPT { - return 89; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionResponseEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MassActionResponse::Value - massActionResponse() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 89, sizeof(std::uint8_t)); - return MassActionResponse::get((val)); - } - - OrderMassActionReport558 & - massActionResponse(const MassActionResponse::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 89, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 90; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 90, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - OrderMassActionReport558 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 90, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MassActionScopeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t massActionScopeId() SBE_NOEXCEPT { - return 1374; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionScopeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool massActionScopeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= massActionScopeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionScopeEncodingOffset() SBE_NOEXCEPT { - return 91; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionScopeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MassActionScope::Value massActionScope() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t)); - return MassActionScope::get((val)); - } - - OrderMassActionReport558 & - massActionScope(const MassActionScope::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 91, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *TotalAffectedOrdersMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t totalAffectedOrdersId() SBE_NOEXCEPT { - return 533; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totalAffectedOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool totalAffectedOrdersInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= totalAffectedOrdersSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totalAffectedOrdersEncodingOffset() SBE_NOEXCEPT { - return 92; - } - - static SBE_CONSTEXPR std::uint8_t - totalAffectedOrdersNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - totalAffectedOrdersMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - totalAffectedOrdersMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - totalAffectedOrdersEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t totalAffectedOrders() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint8_t)); - return (val); - } - - OrderMassActionReport558 & - totalAffectedOrders(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - LastFragmentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t lastFragmentId() SBE_NOEXCEPT { - return 893; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastFragmentSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lastFragmentInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lastFragmentSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastFragmentEncodingOffset() SBE_NOEXCEPT { - return 93; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastFragmentEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value lastFragment() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 93, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - OrderMassActionReport558 & - lastFragment(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 93, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MassActionRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t massActionRejectReasonId() SBE_NOEXCEPT { - return 1376; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool massActionRejectReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= massActionRejectReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 94; - } - - static SBE_CONSTEXPR std::uint8_t - massActionRejectReasonNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } - - static SBE_CONSTEXPR std::uint8_t - massActionRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - massActionRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - massActionRejectReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t massActionRejectReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 94, sizeof(std::uint8_t)); - return (val); - } - - OrderMassActionReport558 & - massActionRejectReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 94, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MarketSegmentIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t marketSegmentIDId() SBE_NOEXCEPT { - return 1300; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketSegmentIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool marketSegmentIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= marketSegmentIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketSegmentIDEncodingOffset() SBE_NOEXCEPT { - return 95; - } - - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } - - static SBE_CONSTEXPR std::uint8_t marketSegmentIDMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t marketSegmentIDMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - marketSegmentIDEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t marketSegmentID() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 95, sizeof(std::uint8_t)); - return (val); - } - - OrderMassActionReport558 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 95, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MassCancelRequestTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t massCancelRequestTypeId() SBE_NOEXCEPT { - return 6115; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massCancelRequestTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool massCancelRequestTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= massCancelRequestTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massCancelRequestTypeEncodingOffset() SBE_NOEXCEPT { - return 96; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massCancelRequestTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MassCxlReqTyp::Value - massCancelRequestType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 96, sizeof(std::uint8_t)); - return MassCxlReqTyp::get((val)); - } - - OrderMassActionReport558 & - massCancelRequestType(const MassCxlReqTyp::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 96, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 97; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SideNULL::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 97, sizeof(std::uint8_t)); - return SideNULL::get((val)); - } - - OrderMassActionReport558 &side(const SideNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 97, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= ordTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 98; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MassActionOrdTyp::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 98, sizeof(char)); - return MassActionOrdTyp::get((val)); - } - - OrderMassActionReport558 & - ordType(const MassActionOrdTyp::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 98, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= timeInForceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 99; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MassCancelTIF::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 99, sizeof(std::uint8_t)); - return MassCancelTIF::get((val)); - } - - OrderMassActionReport558 & - timeInForce(const MassCancelTIF::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 99, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= splitMsgSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 100; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } - - OrderMassActionReport558 & - splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= liquidityFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 101; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 101, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - OrderMassActionReport558 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 101, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= possRetransFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 102; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - if (m_actingVersion < 2) { - return BooleanFlag::NULL_VALUE; - } - - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 102, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - OrderMassActionReport558 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 102, &val, sizeof(std::uint8_t)); - return *this; - } - - class NoAffectedOrders { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = std::numeric_limits::max(); - m_actingVersion = actingVersion; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)32); - dimensions.numInGroup((std::uint8_t)count); - m_index = std::numeric_limits::max(); - m_count = count; - m_blockLength = 32; - m_actingVersion = actingVersion; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 32; - } - - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } - - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index + 1 < m_count; - } - - inline NoAffectedOrders &next() { - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short to support next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - OrigCIOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t origCIOrdIDId() SBE_NOEXCEPT { - return 41; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - origCIOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool origCIOrdIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= origCIOrdIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - origCIOrdIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char origCIOrdIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char origCIOrdIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char origCIOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - origCIOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t origCIOrdIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *origCIOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *origCIOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char origCIOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error( - "index out of range for origCIOrdID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoAffectedOrders & - origCIOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error( - "index out of range for origCIOrdID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getOrigCIOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getOrigCIOrdID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoAffectedOrders &putOrigCIOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); - return *this; - } - - std::string getOrigCIOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getOrigCIOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrigCIOrdIDAsString(); - - for (auto c = s.cbegin(); c != s.cend(); c++) { - switch (*c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - std::string_view getOrigCIOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoAffectedOrders &putOrigCIOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putOrigCIOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoAffectedOrders &putOrigCIOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putOrigCIOrdID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *AffectedOrderIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t affectedOrderIDId() SBE_NOEXCEPT { - return 535; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - affectedOrderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool affectedOrderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= affectedOrderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - affectedOrderIDEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t - affectedOrderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - affectedOrderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - affectedOrderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - affectedOrderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t affectedOrderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoAffectedOrders & - affectedOrderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - CxlQuantityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t cxlQuantityId() SBE_NOEXCEPT { - return 84; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cxlQuantitySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool cxlQuantityInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= cxlQuantitySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cxlQuantityEncodingOffset() SBE_NOEXCEPT { - return 28; - } - - static SBE_CONSTEXPR std::uint32_t cxlQuantityNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t cxlQuantityMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t cxlQuantityMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - cxlQuantityEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t cxlQuantity() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoAffectedOrders &cxlQuantity(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint32_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoAffectedOrders writer) { - builder << '{'; - builder << R"("OrigCIOrdID": )"; - builder << '"' << writer.getOrigCIOrdIDAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("AffectedOrderID": )"; - builder << +writer.affectedOrderID(); - - builder << ", "; - builder << R"("CxlQuantity": )"; - builder << +writer.cxlQuantity(); - - builder << '}'; - - return builder; - } - }; - - private: - NoAffectedOrders m_noAffectedOrders; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoAffectedOrdersId() SBE_NOEXCEPT { - return 534; - } - - SBE_NODISCARD inline NoAffectedOrders &noAffectedOrders() { - m_noAffectedOrders.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noAffectedOrders; - } - - NoAffectedOrders &noAffectedOrdersCount(const std::uint8_t count) { - m_noAffectedOrders.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noAffectedOrders; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noAffectedOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noAffectedOrdersInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noAffectedOrdersSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - OrderMassActionReport558 _writer) { - OrderMassActionReport558 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "OrderMassActionReport558", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); - - builder << ", "; - builder << R"("MassActionReportID": )"; - builder << +writer.massActionReportID(); - - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); - - builder << ", "; - builder << R"("MassActionResponse": )"; - builder << '"' << writer.massActionResponse() << '"'; - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("MassActionScope": )"; - builder << '"' << writer.massActionScope() << '"'; - - builder << ", "; - builder << R"("TotalAffectedOrders": )"; - builder << +writer.totalAffectedOrders(); - - builder << ", "; - builder << R"("LastFragment": )"; - builder << '"' << writer.lastFragment() << '"'; - - builder << ", "; - builder << R"("MassActionRejectReason": )"; - builder << +writer.massActionRejectReason(); - - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); - - builder << ", "; - builder << R"("MassCancelRequestType": )"; - builder << '"' << writer.massCancelRequestType() << '"'; - - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; - - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; - - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; - - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; - - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; - - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoAffectedOrders": [)"; - writer.noAffectedOrders().forEach( - [&](NoAffectedOrders &noAffectedOrders) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noAffectedOrders; - }); - builder << ']'; - } - - builder << '}'; - - return builder; - } -}; -} // namespace iLinkBinary -#endif diff --git a/src/lib/orderman/ilink3/generated/OrderMassActionReport562.h b/src/lib/orderman/ilink3/generated/OrderMassActionReport562.h index 33e2e2df9..1e96482cd 100644 --- a/src/lib/orderman/ilink3/generated/OrderMassActionReport562.h +++ b/src/lib/orderman/ilink3/generated/OrderMassActionReport562.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3141 +86,3855 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class OrderMassActionReport562 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class OrderMassActionReport562 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(130); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(562); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - OrderMassActionReport562() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - OrderMassActionReport562( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - OrderMassActionReport562(char *buffer, const std::uint64_t bufferLength) - : OrderMassActionReport562( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + OrderMassActionReport562() = default; - OrderMassActionReport562( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : OrderMassActionReport562( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + OrderMassActionReport562( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)114; - } + OrderMassActionReport562(char *buffer, const std::uint64_t bufferLength) : + OrderMassActionReport562(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + OrderMassActionReport562( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + OrderMassActionReport562(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)562; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(130); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(562); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "BZ"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - OrderMassActionReport562 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = OrderMassActionReport562( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "BZ"; + } - OrderMassActionReport562 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + OrderMassActionReport562 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = OrderMassActionReport562(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = OrderMassActionReport562( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + OrderMassActionReport562 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - OrderMassActionReport562 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = OrderMassActionReport562( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = OrderMassActionReport562( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + OrderMassActionReport562 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = OrderMassActionReport562(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + OrderMassActionReport562 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - OrderMassActionReport562 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + OrderMassActionReport562 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderMassActionReport562 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + OrderMassActionReport562 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionReport562 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionReport562 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - OrderMassActionReport562 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + OrderMassActionReport562 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - OrderMassActionReport562 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 20); - return *this; - } + OrderMassActionReport562 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderMassActionReport562 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + OrderMassActionReport562 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - OrderMassActionReport562 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + OrderMassActionReport562 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionReport562 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionReport562 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= transactTimeSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 40; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t transactTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t transactTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t transactTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 40, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t transactTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 40, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionReport562 & - transactTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 40, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionReport562 &transactTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 40, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 48; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionReport562 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionReport562 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 56; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 56; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionReport562 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionReport562 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *MassActionReportIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassActionReportIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massActionReportIDId() SBE_NOEXCEPT { - return 1369; - } + static SBE_CONSTEXPR std::uint16_t massActionReportIDId() SBE_NOEXCEPT + { + return 1369; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionReportIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massActionReportIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massActionReportIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massActionReportIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massActionReportIDSinceVersion(); + return m_actingVersion >= massActionReportIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionReportIDEncodingOffset() SBE_NOEXCEPT { - return 64; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionReportIDEncodingOffset() SBE_NOEXCEPT + { + return 64; + } - static SBE_CONSTEXPR std::uint64_t - massActionReportIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t massActionReportIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - massActionReportIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t massActionReportIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - massActionReportIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t massActionReportIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - massActionReportIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t massActionReportIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t massActionReportID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t massActionReportID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionReport562 & - massActionReportID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionReport562 &massActionReportID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - MassActionTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassActionTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massActionTypeId() SBE_NOEXCEPT { - return 1373; - } + static SBE_CONSTEXPR std::uint16_t massActionTypeId() SBE_NOEXCEPT + { + return 1373; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massActionTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massActionTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massActionTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massActionTypeSinceVersion(); + return m_actingVersion >= massActionTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionTypeEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionTypeEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - static SBE_CONSTEXPR char massActionTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char massActionTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char massActionTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char massActionTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char massActionTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char massActionTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - massActionTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t massActionTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t massActionTypeLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t massActionTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *massActionType() const { - static const std::uint8_t massActionTypeValues[] = {51}; + SBE_NODISCARD const char *massActionType() const + { + static const std::uint8_t massActionTypeValues[] = { 51, 0 }; - return (const char *)massActionTypeValues; - } + return (const char *)massActionTypeValues; + } - SBE_NODISCARD char massActionType(const std::uint64_t index) const { - static const std::uint8_t massActionTypeValues[] = {51}; + SBE_NODISCARD char massActionType(const std::uint64_t index) const + { + static const std::uint8_t massActionTypeValues[] = { 51, 0 }; - return (char)massActionTypeValues[index]; - } + return (char)massActionTypeValues[index]; + } - std::uint64_t - getMassActionType(char *dst, const std::uint64_t length) const { - static std::uint8_t massActionTypeValues[] = {51}; - std::uint64_t bytesToCopy = length < sizeof(massActionTypeValues) - ? length - : sizeof(massActionTypeValues); + std::uint64_t getMassActionType(char *dst, const std::uint64_t length) const + { + static std::uint8_t massActionTypeValues[] = { 51 }; + std::uint64_t bytesToCopy = length < sizeof(massActionTypeValues) ? length : sizeof(massActionTypeValues); - std::memcpy(dst, massActionTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, massActionTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getMassActionTypeAsString() const { - static const std::uint8_t MassActionTypeValues[] = {51}; + std::string getMassActionTypeAsString() const + { + static const std::uint8_t MassActionTypeValues[] = { 51 }; - return std::string((const char *)MassActionTypeValues, 1); - } + return std::string((const char *)MassActionTypeValues, 1); + } - std::string getMassActionTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMassActionTypeAsString(); + std::string getMassActionTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMassActionTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT { - return 1151; - } + static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT + { + return 1151; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityGroupSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityGroupSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityGroupSinceVersion(); + return m_actingVersion >= securityGroupSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityGroupEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 72; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 72; + } - SBE_NODISCARD char securityGroup(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E104]"); - } + SBE_NODISCARD char securityGroup(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 72 + (index * 1), sizeof(char)); + return (val); + } - OrderMassActionReport562 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + OrderMassActionReport562 &securityGroup(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 72 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecurityGroup(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error( - "length too large for getSecurityGroup [E106]"); - } + std::uint64_t getSecurityGroup(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getSecurityGroup [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 72, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 72, sizeof(char) * static_cast(length)); + return length; + } - OrderMassActionReport562 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 6); - return *this; - } + OrderMassActionReport562 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 72, src, sizeof(char) * 6); + return *this; + } - SBE_NODISCARD std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSecurityGroupAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityGroupAsString(); + std::string getSecurityGroupAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityGroupAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 72; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 72; + std::size_t length = 0; - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderMassActionReport562 &putSecurityGroup(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } + #if __cplusplus >= 201703L + OrderMassActionReport562 &putSecurityGroup(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.data(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#else - OrderMassActionReport562 &putSecurityGroup(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } + return *this; + } + #else + OrderMassActionReport562 &putSecurityGroup(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } - std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 72 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 72, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 72 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 78; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 78; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 78; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 78; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 78; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 78; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 78 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 78 + (index * 1), sizeof(char)); + return (val); + } - OrderMassActionReport562 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + OrderMassActionReport562 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 78 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 78 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 78, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 78, sizeof(char) * static_cast(length)); + return length; + } - OrderMassActionReport562 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 78, src, sizeof(char) * 5); - return *this; - } + OrderMassActionReport562 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 78, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 78; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 78; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 78; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 78; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderMassActionReport562 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + OrderMassActionReport562 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 78, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 78 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 78, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 78 + start] = 0; + } - return *this; - } -#else - OrderMassActionReport562 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + OrderMassActionReport562 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 78, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 78 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 78, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 78 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 83; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 83; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 83, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 83, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderMassActionReport562 &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 83, &val, sizeof(std::int32_t)); - return *this; - } + OrderMassActionReport562 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 83, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 87; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 87; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - OrderMassActionReport562 & - delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint16_t)); - return *this; - } + OrderMassActionReport562 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *MassActionResponseMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassActionResponseMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massActionResponseId() SBE_NOEXCEPT { - return 1375; - } + static SBE_CONSTEXPR std::uint16_t massActionResponseId() SBE_NOEXCEPT + { + return 1375; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionResponseSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massActionResponseSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massActionResponseInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massActionResponseInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massActionResponseSinceVersion(); + return m_actingVersion >= massActionResponseSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionResponseEncodingOffset() SBE_NOEXCEPT { - return 89; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionResponseEncodingOffset() SBE_NOEXCEPT + { + return 89; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionResponseEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionResponseEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassActionResponse::Value - massActionResponse() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 89, sizeof(std::uint8_t)); - return MassActionResponse::get((val)); - } + SBE_NODISCARD std::uint8_t massActionResponseRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 89, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - massActionResponse(const MassActionResponse::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 89, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassActionResponse::Value massActionResponse() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 89, sizeof(std::uint8_t)); + return MassActionResponse::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionReport562 &massActionResponse(const MassActionResponse::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 89, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 90; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 90; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 90, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 90, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 90, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 90, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char *MassActionScopeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionReport562 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 90, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t massActionScopeId() SBE_NOEXCEPT { - return 1374; - } + SBE_NODISCARD static const char *MassActionScopeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionScopeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t massActionScopeId() SBE_NOEXCEPT + { + return 1374; + } - SBE_NODISCARD bool massActionScopeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massActionScopeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool massActionScopeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massActionScopeSinceVersion(); + return m_actingVersion >= massActionScopeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionScopeEncodingOffset() SBE_NOEXCEPT { - return 91; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionScopeEncodingOffset() SBE_NOEXCEPT + { + return 91; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionScopeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionScopeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassActionScope::Value massActionScope() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t)); - return MassActionScope::get((val)); - } + SBE_NODISCARD std::uint8_t massActionScopeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - massActionScope(const MassActionScope::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 91, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassActionScope::Value massActionScope() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t)); + return MassActionScope::get((val)); + } - SBE_NODISCARD static const char *TotalAffectedOrdersMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionReport562 &massActionScope(const MassActionScope::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 91, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t totalAffectedOrdersId() SBE_NOEXCEPT { - return 533; - } + SBE_NODISCARD static const char *TotalAffectedOrdersMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totalAffectedOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t totalAffectedOrdersId() SBE_NOEXCEPT + { + return 533; + } - SBE_NODISCARD bool totalAffectedOrdersInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totalAffectedOrdersSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool totalAffectedOrdersInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totalAffectedOrdersSinceVersion(); + return m_actingVersion >= totalAffectedOrdersSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totalAffectedOrdersEncodingOffset() SBE_NOEXCEPT { - return 92; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totalAffectedOrdersEncodingOffset() SBE_NOEXCEPT + { + return 92; + } - static SBE_CONSTEXPR std::uint32_t - totalAffectedOrdersNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t totalAffectedOrdersNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t - totalAffectedOrdersMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totalAffectedOrdersMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t - totalAffectedOrdersMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totalAffectedOrdersMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t - totalAffectedOrdersEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totalAffectedOrdersEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totalAffectedOrders() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t totalAffectedOrders() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderMassActionReport562 & - totalAffectedOrders(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint32_t)); - return *this; - } + OrderMassActionReport562 &totalAffectedOrders(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - LastFragmentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastFragmentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastFragmentId() SBE_NOEXCEPT { - return 893; - } + static SBE_CONSTEXPR std::uint16_t lastFragmentId() SBE_NOEXCEPT + { + return 893; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastFragmentSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastFragmentSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastFragmentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastFragmentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastFragmentSinceVersion(); + return m_actingVersion >= lastFragmentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastFragmentEncodingOffset() SBE_NOEXCEPT { - return 96; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastFragmentEncodingOffset() SBE_NOEXCEPT + { + return 96; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastFragmentEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastFragmentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value lastFragment() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 96, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t lastFragmentRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 96, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - lastFragment(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 96, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value lastFragment() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 96, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char *MassActionRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + OrderMassActionReport562 &lastFragment(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 96, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t massActionRejectReasonId() SBE_NOEXCEPT { - return 1376; - } + SBE_NODISCARD static const char *MassActionRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t massActionRejectReasonId() SBE_NOEXCEPT + { + return 1376; + } - SBE_NODISCARD bool massActionRejectReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massActionRejectReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool massActionRejectReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massActionRejectReasonSinceVersion(); + return m_actingVersion >= massActionRejectReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 97; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionRejectReasonEncodingOffset() SBE_NOEXCEPT + { + return 97; + } - static SBE_CONSTEXPR std::uint8_t - massActionRejectReasonNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t massActionRejectReasonNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t - massActionRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t massActionRejectReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t - massActionRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t massActionRejectReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - massActionRejectReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t massActionRejectReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t massActionRejectReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 97, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t massActionRejectReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 97, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - massActionRejectReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 97, &val, sizeof(std::uint8_t)); - return *this; - } + OrderMassActionReport562 &massActionRejectReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 97, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *MarketSegmentIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MarketSegmentIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t marketSegmentIDId() SBE_NOEXCEPT { - return 1300; - } + static SBE_CONSTEXPR std::uint16_t marketSegmentIDId() SBE_NOEXCEPT + { + return 1300; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketSegmentIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t marketSegmentIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool marketSegmentIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool marketSegmentIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= marketSegmentIDSinceVersion(); + return m_actingVersion >= marketSegmentIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketSegmentIDEncodingOffset() SBE_NOEXCEPT { - return 98; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingOffset() SBE_NOEXCEPT + { + return 98; + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - marketSegmentIDEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t marketSegmentID() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 98, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t marketSegmentID() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 98, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 98, &val, sizeof(std::uint8_t)); - return *this; - } + OrderMassActionReport562 &marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 98, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *MassCancelRequestTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassCancelRequestTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massCancelRequestTypeId() SBE_NOEXCEPT { - return 6115; - } + static SBE_CONSTEXPR std::uint16_t massCancelRequestTypeId() SBE_NOEXCEPT + { + return 6115; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massCancelRequestTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massCancelRequestTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massCancelRequestTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massCancelRequestTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massCancelRequestTypeSinceVersion(); + return m_actingVersion >= massCancelRequestTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massCancelRequestTypeEncodingOffset() SBE_NOEXCEPT { - return 99; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massCancelRequestTypeEncodingOffset() SBE_NOEXCEPT + { + return 99; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massCancelRequestTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massCancelRequestTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassCxlReqTyp::Value - massCancelRequestType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 99, sizeof(std::uint8_t)); - return MassCxlReqTyp::get((val)); - } + SBE_NODISCARD std::uint8_t massCancelRequestTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 99, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - massCancelRequestType(const MassCxlReqTyp::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 99, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassCxlReqTyp::Value massCancelRequestType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 99, sizeof(std::uint8_t)); + return MassCxlReqTyp::get((val)); + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionReport562 &massCancelRequestType(const MassCxlReqTyp::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 99, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 100; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 100; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideNULL::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint8_t)); - return SideNULL::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 &side(const SideNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideNULL::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 100, sizeof(std::uint8_t)); + return SideNULL::get((val)); + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionReport562 &side(const SideNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 100, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 101; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 101; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassActionOrdTyp::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 101, sizeof(char)); - return MassActionOrdTyp::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 101, sizeof(char)); + return (val); + } - OrderMassActionReport562 & - ordType(const MassActionOrdTyp::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 101, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD MassActionOrdTyp::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 101, sizeof(char)); + return MassActionOrdTyp::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionReport562 &ordType(const MassActionOrdTyp::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 101, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 102; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 102; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassCancelTIF::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 102, sizeof(std::uint8_t)); - return MassCancelTIF::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 102, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - timeInForce(const MassCancelTIF::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 102, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassCancelTIF::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 102, sizeof(std::uint8_t)); + return MassCancelTIF::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionReport562 &timeInForce(const MassCancelTIF::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 102, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 103; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 103; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 103, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 103, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 103, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 103, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionReport562 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 103, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 104; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 104; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 104, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 104, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 104, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 104, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionReport562 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 104, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 105; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 105; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 105, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 105, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionReport562 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 105, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 105, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + OrderMassActionReport562 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 105, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 106; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 106; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 106, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 106, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionReport562 & - delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 106, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionReport562 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 106, &val, sizeof(std::uint64_t)); + return *this; + } - class NoAffectedOrders { + SBE_NODISCARD static const char *OrigOrderUserMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origOrderUserId() SBE_NOEXCEPT + { + return 9937; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origOrderUserSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool origOrderUserInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origOrderUserSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origOrderUserEncodingOffset() SBE_NOEXCEPT + { + return 114; + } + + static SBE_CONSTEXPR char origOrderUserNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char origOrderUserMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char origOrderUserMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t origOrderUserEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t origOrderUserLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *origOrderUser() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 114; + } + + SBE_NODISCARD char *origOrderUser() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 114; + } + + SBE_NODISCARD char origOrderUser(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 114 + (index * 1), sizeof(char)); + return (val); + } + + OrderMassActionReport562 &origOrderUser(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 114 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrigOrderUser(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getOrigOrderUser [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 114, sizeof(char) * static_cast(length)); + return length; + } + + OrderMassActionReport562 &putOrigOrderUser(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 114, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getOrigOrderUserAsString() const + { + const char *buffer = m_buffer + m_offset + 114; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrigOrderUserAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrigOrderUserAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrigOrderUserAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 114; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + OrderMassActionReport562 &putOrigOrderUser(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 114, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 114 + start] = 0; + } + + return *this; + } + #else + OrderMassActionReport562 &putOrigOrderUser(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 114, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 114 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *CancelTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cancelTextId() SBE_NOEXCEPT + { + return 2807; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cancelTextSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool cancelTextInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cancelTextSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cancelTextEncodingOffset() SBE_NOEXCEPT + { + return 122; + } + + static SBE_CONSTEXPR char cancelTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char cancelTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char cancelTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t cancelTextEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t cancelTextLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *cancelText() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 122; + } + + SBE_NODISCARD char *cancelText() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 122; + } + + SBE_NODISCARD char cancelText(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 122 + (index * 1), sizeof(char)); + return (val); + } + + OrderMassActionReport562 &cancelText(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 122 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getCancelText(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getCancelText [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 122, sizeof(char) * static_cast(length)); + return length; + } + + OrderMassActionReport562 &putCancelText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 122, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getCancelTextAsString() const + { + const char *buffer = m_buffer + m_offset + 122; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getCancelTextAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getCancelTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCancelTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 122; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + OrderMassActionReport562 &putCancelText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 122, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 122 + start] = 0; + } + + return *this; + } + #else + OrderMassActionReport562 &putCancelText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 122, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 122 + start] = 0; + } + + return *this; + } + #endif + + class NoAffectedOrders + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)32); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 32; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 32; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoAffectedOrders &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - OrigCIOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t origCIOrdIDId() SBE_NOEXCEPT { - return 41; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - origCIOrdIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool origCIOrdIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= origCIOrdIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - origCIOrdIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char origCIOrdIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char origCIOrdIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char origCIOrdIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - origCIOrdIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t origCIOrdIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *origCIOrdID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *origCIOrdID() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char origCIOrdID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error( - "index out of range for origCIOrdID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoAffectedOrders & - origCIOrdID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error( - "index out of range for origCIOrdID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getOrigCIOrdID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getOrigCIOrdID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoAffectedOrders &putOrigCIOrdID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getOrigCIOrdIDAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getOrigCIOrdIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getOrigCIOrdIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(32)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 32; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - return oss.str(); - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getOrigCIOrdIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 32; + } - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - return result; - } -#endif + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } -#if __cplusplus >= 201703L - NoAffectedOrders &putOrigCIOrdID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putOrigCIOrdID [E106]"); - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - return *this; - } -#else - NoAffectedOrders &putOrigCIOrdID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putOrigCIOrdID [E106]"); - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + inline NoAffectedOrders &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - return *this; - } -#endif + return *this; + } - SBE_NODISCARD static const char *AffectedOrderIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } - static SBE_CONSTEXPR std::uint16_t affectedOrderIDId() SBE_NOEXCEPT { - return 535; - } + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - affectedOrderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - SBE_NODISCARD bool affectedOrderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= affectedOrderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD static const char *OrigCIOrdIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - affectedOrderIDEncodingOffset() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint16_t origCIOrdIDId() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR std::uint64_t - affectedOrderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origCIOrdIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t - affectedOrderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + SBE_NODISCARD bool origCIOrdIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= origCIOrdIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - static SBE_CONSTEXPR std::uint64_t - affectedOrderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origCIOrdIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::size_t - affectedOrderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR char origCIOrdIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - SBE_NODISCARD std::uint64_t affectedOrderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + static SBE_CONSTEXPR char origCIOrdIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - NoAffectedOrders & - affectedOrderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint64_t)); - return *this; - } + static SBE_CONSTEXPR char origCIOrdIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - SBE_NODISCARD static const char * - CxlQuantityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::size_t origCIOrdIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint16_t cxlQuantityId() SBE_NOEXCEPT { - return 84; - } + static SBE_CONSTEXPR std::uint64_t origCIOrdIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cxlQuantitySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD const char *origCIOrdID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD bool cxlQuantityInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= cxlQuantitySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD char *origCIOrdID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cxlQuantityEncodingOffset() SBE_NOEXCEPT { - return 28; - } + SBE_NODISCARD char origCIOrdID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for origCIOrdID [E104]"); + } - static SBE_CONSTEXPR std::uint32_t cxlQuantityNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - static SBE_CONSTEXPR std::uint32_t cxlQuantityMinValue() SBE_NOEXCEPT { - return 0; - } + NoAffectedOrders &origCIOrdID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for origCIOrdID [E105]"); + } - static SBE_CONSTEXPR std::uint32_t cxlQuantityMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::size_t - cxlQuantityEncodingLength() SBE_NOEXCEPT { - return 4; - } + std::uint64_t getOrigCIOrdID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getOrigCIOrdID [E106]"); + } - SBE_NODISCARD std::uint32_t cxlQuantity() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - NoAffectedOrders &cxlQuantity(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint32_t)); - return *this; - } + NoAffectedOrders &putOrigCIOrdID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoAffectedOrders writer) { - builder << '{'; - builder << R"("OrigCIOrdID": )"; - builder << '"' << writer.getOrigCIOrdIDAsJsonEscapedString().c_str() - << '"'; + SBE_NODISCARD std::string getOrigCIOrdIDAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - builder << ", "; - builder << R"("AffectedOrderID": )"; - builder << +writer.affectedOrderID(); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - builder << ", "; - builder << R"("CxlQuantity": )"; - builder << +writer.cxlQuantity(); + return result; + } - builder << '}'; + std::string getOrigCIOrdIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getOrigCIOrdIDAsString(); - return builder; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - void skip() {} + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return oss.str(); + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrigCIOrdIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoAffectedOrders &putOrigCIOrdID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putOrigCIOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoAffectedOrders &putOrigCIOrdID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putOrigCIOrdID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *AffectedOrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t affectedOrderIDId() SBE_NOEXCEPT + { + return 535; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t affectedOrderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool affectedOrderIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= affectedOrderIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t affectedOrderIDEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t affectedOrderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t affectedOrderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t affectedOrderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t affectedOrderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t affectedOrderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoAffectedOrders &affectedOrderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *CxlQuantityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cxlQuantityId() SBE_NOEXCEPT + { + return 84; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cxlQuantitySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool cxlQuantityInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= cxlQuantitySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cxlQuantityEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + static SBE_CONSTEXPR std::uint32_t cxlQuantityNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t cxlQuantityMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t cxlQuantityMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t cxlQuantityEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t cxlQuantity() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoAffectedOrders &cxlQuantity(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint32_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoAffectedOrders writer) + { + builder << '{'; + builder << R"("OrigCIOrdID": )"; + builder << '"' << + writer.getOrigCIOrdIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("AffectedOrderID": )"; + builder << +writer.affectedOrderID(); + + builder << ", "; + builder << R"("CxlQuantity": )"; + builder << +writer.cxlQuantity(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoAffectedOrders m_noAffectedOrders; +private: + NoAffectedOrders m_noAffectedOrders; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoAffectedOrdersId() SBE_NOEXCEPT { - return 534; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoAffectedOrdersId() SBE_NOEXCEPT + { + return 534; + } - SBE_NODISCARD inline NoAffectedOrders &noAffectedOrders() { - m_noAffectedOrders.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noAffectedOrders; - } + SBE_NODISCARD inline NoAffectedOrders &noAffectedOrders() + { + m_noAffectedOrders.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noAffectedOrders; + } - NoAffectedOrders &noAffectedOrdersCount(const std::uint8_t count) { - m_noAffectedOrders.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noAffectedOrders; - } + NoAffectedOrders &noAffectedOrdersCount(const std::uint8_t count) + { + m_noAffectedOrders.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noAffectedOrders; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noAffectedOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noAffectedOrdersSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noAffectedOrdersInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noAffectedOrdersInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noAffectedOrdersSinceVersion(); + return m_actingVersion >= noAffectedOrdersSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - OrderMassActionReport562 _writer) { - OrderMassActionReport562 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "OrderMassActionReport562", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, OrderMassActionReport562 _writer) +{ + OrderMassActionReport562 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << '{'; + builder << R"("Name": "OrderMassActionReport562", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("MassActionReportID": )"; - builder << +writer.massActionReportID(); + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("MassActionReportID": )"; + builder << +writer.massActionReportID(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("MassActionResponse": )"; - builder << '"' << writer.massActionResponse() << '"'; + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("MassActionResponse": )"; + builder << '"' << writer.massActionResponse() << '"'; - builder << ", "; - builder << R"("MassActionScope": )"; - builder << '"' << writer.massActionScope() << '"'; + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - builder << ", "; - builder << R"("TotalAffectedOrders": )"; - builder << +writer.totalAffectedOrders(); + builder << ", "; + builder << R"("MassActionScope": )"; + builder << '"' << writer.massActionScope() << '"'; - builder << ", "; - builder << R"("LastFragment": )"; - builder << '"' << writer.lastFragment() << '"'; + builder << ", "; + builder << R"("TotalAffectedOrders": )"; + builder << +writer.totalAffectedOrders(); - builder << ", "; - builder << R"("MassActionRejectReason": )"; - builder << +writer.massActionRejectReason(); + builder << ", "; + builder << R"("LastFragment": )"; + builder << '"' << writer.lastFragment() << '"'; - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); + builder << ", "; + builder << R"("MassActionRejectReason": )"; + builder << +writer.massActionRejectReason(); - builder << ", "; - builder << R"("MassCancelRequestType": )"; - builder << '"' << writer.massCancelRequestType() << '"'; + builder << ", "; + builder << R"("MarketSegmentID": )"; + builder << +writer.marketSegmentID(); - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + builder << ", "; + builder << R"("MassCancelRequestType": )"; + builder << '"' << writer.massCancelRequestType() << '"'; - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoAffectedOrders": [)"; - writer.noAffectedOrders().forEach( - [&](NoAffectedOrders &noAffectedOrders) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); + + builder << ", "; + builder << R"("OrigOrderUser": )"; + builder << '"' << + writer.getOrigOrderUserAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("CancelText": )"; + builder << '"' << + writer.getCancelTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoAffectedOrders": [)"; + writer.noAffectedOrders().forEach( + [&](NoAffectedOrders &noAffectedOrders) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noAffectedOrders; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} - void skip() { - noAffectedOrders().forEach([](NoAffectedOrders e) { e.skip(); }); - } +void skip() +{ + auto &noAffectedOrdersGroup { noAffectedOrders() }; + while (noAffectedOrdersGroup.hasNext()) + { + noAffectedOrdersGroup.next().skip(); + } +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t NoAffectedOrdersLength = 0) { +SBE_NODISCARD static std::size_t computeLength(std::size_t noAffectedOrdersLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoAffectedOrders::sbeHeaderSize(); - if (NoAffectedOrdersLength > 254) { - throw std::runtime_error( - "NoAffectedOrdersLength outside of allowed range [E110]"); - } - length += NoAffectedOrdersLength * NoAffectedOrders::sbeBlockLength(); - return length; + length += NoAffectedOrders::sbeHeaderSize(); + if (noAffectedOrdersLength > 254LL) + { + throw std::runtime_error("noAffectedOrdersLength outside of allowed range [E110]"); + } + length += noAffectedOrdersLength *NoAffectedOrders::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderMassActionRequest529.h b/src/lib/orderman/ilink3/generated/OrderMassActionRequest529.h index 090337cdc..d2dd9f737 100644 --- a/src/lib/orderman/ilink3/generated/OrderMassActionRequest529.h +++ b/src/lib/orderman/ilink3/generated/OrderMassActionRequest529.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1827 +86,2221 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class OrderMassActionRequest529 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class OrderMassActionRequest529 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(79); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(529); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - OrderMassActionRequest529() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - OrderMassActionRequest529( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - OrderMassActionRequest529(char *buffer, const std::uint64_t bufferLength) - : OrderMassActionRequest529( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + OrderMassActionRequest529() = default; - OrderMassActionRequest529( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : OrderMassActionRequest529( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + OrderMassActionRequest529( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)71; - } + OrderMassActionRequest529(char *buffer, const std::uint64_t bufferLength) : + OrderMassActionRequest529(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + OrderMassActionRequest529( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + OrderMassActionRequest529(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)529; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(79); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(529); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "CA"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - OrderMassActionRequest529 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = OrderMassActionRequest529( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "CA"; + } - OrderMassActionRequest529 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + OrderMassActionRequest529 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = OrderMassActionRequest529(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = OrderMassActionRequest529( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + OrderMassActionRequest529 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - OrderMassActionRequest529 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = OrderMassActionRequest529( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = OrderMassActionRequest529( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + OrderMassActionRequest529 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = OrderMassActionRequest529(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + OrderMassActionRequest529 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - OrderMassActionRequest529 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + OrderMassActionRequest529 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionRequest529 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionRequest529 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderRequestIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT { - return 2422; - } + static SBE_CONSTEXPR std::uint16_t orderRequestIDId() SBE_NOEXCEPT + { + return 2422; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderRequestIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderRequestIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderRequestIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderRequestIDSinceVersion(); + return m_actingVersion >= orderRequestIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderRequestIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderRequestIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - orderRequestIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderRequestIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderRequestID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionRequest529 & - orderRequestID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionRequest529 &orderRequestID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionRequest529 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionRequest529 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderMassActionRequest529 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + OrderMassActionRequest529 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - OrderMassActionRequest529 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + OrderMassActionRequest529 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - OrderMassActionRequest529 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + OrderMassActionRequest529 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderMassActionRequest529 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + OrderMassActionRequest529 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - OrderMassActionRequest529 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + OrderMassActionRequest529 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - MassActionTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassActionTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massActionTypeId() SBE_NOEXCEPT { - return 1373; - } + static SBE_CONSTEXPR std::uint16_t massActionTypeId() SBE_NOEXCEPT + { + return 1373; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massActionTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massActionTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massActionTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massActionTypeSinceVersion(); + return m_actingVersion >= massActionTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionTypeEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionTypeEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR char massActionTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char massActionTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char massActionTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char massActionTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char massActionTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char massActionTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - massActionTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t massActionTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t massActionTypeLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t massActionTypeLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *massActionType() const { - static const std::uint8_t massActionTypeValues[] = {51}; + SBE_NODISCARD const char *massActionType() const + { + static const std::uint8_t massActionTypeValues[] = { 51, 0 }; - return (const char *)massActionTypeValues; - } + return (const char *)massActionTypeValues; + } - SBE_NODISCARD char massActionType(const std::uint64_t index) const { - static const std::uint8_t massActionTypeValues[] = {51}; + SBE_NODISCARD char massActionType(const std::uint64_t index) const + { + static const std::uint8_t massActionTypeValues[] = { 51, 0 }; - return (char)massActionTypeValues[index]; - } + return (char)massActionTypeValues[index]; + } - std::uint64_t - getMassActionType(char *dst, const std::uint64_t length) const { - static std::uint8_t massActionTypeValues[] = {51}; - std::uint64_t bytesToCopy = length < sizeof(massActionTypeValues) - ? length - : sizeof(massActionTypeValues); + std::uint64_t getMassActionType(char *dst, const std::uint64_t length) const + { + static std::uint8_t massActionTypeValues[] = { 51 }; + std::uint64_t bytesToCopy = length < sizeof(massActionTypeValues) ? length : sizeof(massActionTypeValues); - std::memcpy(dst, massActionTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + std::memcpy(dst, massActionTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getMassActionTypeAsString() const { - static const std::uint8_t MassActionTypeValues[] = {51}; + std::string getMassActionTypeAsString() const + { + static const std::uint8_t MassActionTypeValues[] = { 51 }; - return std::string((const char *)MassActionTypeValues, 1); - } + return std::string((const char *)MassActionTypeValues, 1); + } - std::string getMassActionTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMassActionTypeAsString(); + std::string getMassActionTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMassActionTypeAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassActionRequest529 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassActionRequest529 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT { - return 1151; - } + static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT + { + return 1151; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityGroupSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityGroupSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityGroupSinceVersion(); + return m_actingVersion >= securityGroupSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityGroupEncodingOffset() SBE_NOEXCEPT { - return 49; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 49; + } - static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } - SBE_NODISCARD char securityGroup(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E104]"); - } + SBE_NODISCARD char securityGroup(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); + return (val); + } - OrderMassActionRequest529 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + OrderMassActionRequest529 &securityGroup(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecurityGroup(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error( - "length too large for getSecurityGroup [E106]"); - } + std::uint64_t getSecurityGroup(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getSecurityGroup [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 49, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast(length)); + return length; + } - OrderMassActionRequest529 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 6); - return *this; - } + OrderMassActionRequest529 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 6); + return *this; + } - SBE_NODISCARD std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSecurityGroupAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityGroupAsString(); + std::string getSecurityGroupAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityGroupAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderMassActionRequest529 &putSecurityGroup(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } + #if __cplusplus >= 201703L + OrderMassActionRequest529 &putSecurityGroup(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } - std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } - return *this; - } -#else - OrderMassActionRequest529 &putSecurityGroup(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } + return *this; + } + #else + OrderMassActionRequest529 &putSecurityGroup(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } - std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 55; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 55; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 55; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 55; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 55; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 55; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 55 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 55 + (index * 1), sizeof(char)); + return (val); + } - OrderMassActionRequest529 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + OrderMassActionRequest529 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 55 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 55 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 55, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 55, sizeof(char) * static_cast(length)); + return length; + } - OrderMassActionRequest529 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 55, src, sizeof(char) * 5); - return *this; - } + OrderMassActionRequest529 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 55, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 55; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 55; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 55; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 55; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderMassActionRequest529 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + OrderMassActionRequest529 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 55, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 55 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 55, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 55 + start] = 0; + } - return *this; - } -#else - OrderMassActionRequest529 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + OrderMassActionRequest529 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 55, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 55 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 55, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 55 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 60; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderMassActionRequest529 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 60, &val, sizeof(std::int32_t)); - return *this; - } + OrderMassActionRequest529 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 60, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char *MassActionScopeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassActionScopeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massActionScopeId() SBE_NOEXCEPT { - return 1374; - } + static SBE_CONSTEXPR std::uint16_t massActionScopeId() SBE_NOEXCEPT + { + return 1374; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massActionScopeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massActionScopeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massActionScopeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massActionScopeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massActionScopeSinceVersion(); + return m_actingVersion >= massActionScopeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionScopeEncodingOffset() SBE_NOEXCEPT { - return 64; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionScopeEncodingOffset() SBE_NOEXCEPT + { + return 64; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massActionScopeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massActionScopeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassActionScope::Value massActionScope() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t)); - return MassActionScope::get((val)); - } + SBE_NODISCARD std::uint8_t massActionScopeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionRequest529 & - massActionScope(const MassActionScope::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassActionScope::Value massActionScope() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t)); + return MassActionScope::get((val)); + } - SBE_NODISCARD static const char *MarketSegmentIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + OrderMassActionRequest529 &massActionScope(const MassActionScope::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t marketSegmentIDId() SBE_NOEXCEPT { - return 1300; - } + SBE_NODISCARD static const char *MarketSegmentIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketSegmentIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t marketSegmentIDId() SBE_NOEXCEPT + { + return 1300; + } - SBE_NODISCARD bool marketSegmentIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t marketSegmentIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool marketSegmentIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= marketSegmentIDSinceVersion(); + return m_actingVersion >= marketSegmentIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketSegmentIDEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - marketSegmentIDEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t marketSegmentID() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 65, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t marketSegmentID() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 65, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionRequest529 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 65, &val, sizeof(std::uint8_t)); - return *this; - } + OrderMassActionRequest529 &marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 65, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *MassCancelRequestTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassCancelRequestTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massCancelRequestTypeId() SBE_NOEXCEPT { - return 6115; - } + static SBE_CONSTEXPR std::uint16_t massCancelRequestTypeId() SBE_NOEXCEPT + { + return 6115; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massCancelRequestTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massCancelRequestTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massCancelRequestTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massCancelRequestTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massCancelRequestTypeSinceVersion(); + return m_actingVersion >= massCancelRequestTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massCancelRequestTypeEncodingOffset() SBE_NOEXCEPT { - return 66; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massCancelRequestTypeEncodingOffset() SBE_NOEXCEPT + { + return 66; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massCancelRequestTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massCancelRequestTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassCxlReqTyp::Value - massCancelRequestType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); - return MassCxlReqTyp::get((val)); - } + SBE_NODISCARD std::uint8_t massCancelRequestTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionRequest529 & - massCancelRequestType(const MassCxlReqTyp::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassCxlReqTyp::Value massCancelRequestType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return MassCxlReqTyp::get((val)); + } - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionRequest529 &massCancelRequestType(const MassCxlReqTyp::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sideSinceVersion(); + return m_actingVersion >= sideSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 67; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 67; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SideNULL::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); - return SideNULL::get((val)); - } + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionRequest529 &side(const SideNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SideNULL::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); + return SideNULL::get((val)); + } - SBE_NODISCARD static const char * - OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionRequest529 &side(const SideNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT { return 40; } + SBE_NODISCARD static const char *OrdTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t ordTypeId() SBE_NOEXCEPT + { + return 40; + } - SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordTypeSinceVersion(); + return m_actingVersion >= ordTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingOffset() SBE_NOEXCEPT { - return 68; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingOffset() SBE_NOEXCEPT + { + return 68; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassActionOrdTyp::Value ordType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 68, sizeof(char)); - return MassActionOrdTyp::get((val)); - } + SBE_NODISCARD char ordTypeRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 68, sizeof(char)); + return (val); + } - OrderMassActionRequest529 & - ordType(const MassActionOrdTyp::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 68, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD MassActionOrdTyp::Value ordType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 68, sizeof(char)); + return MassActionOrdTyp::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionRequest529 &ordType(const MassActionOrdTyp::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 68, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 69; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 69; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassCancelTIF::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t)); - return MassCancelTIF::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionRequest529 & - timeInForce(const MassCancelTIF::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassCancelTIF::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t)); + return MassCancelTIF::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassActionRequest529 &timeInForce(const MassCancelTIF::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 70; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 70; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t)); + return (val); + } - OrderMassActionRequest529 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 70, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 70, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - OrderMassActionRequest529 _writer) { - OrderMassActionRequest529 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "OrderMassActionRequest529", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + OrderMassActionRequest529 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 70, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + SBE_NODISCARD static const char *OrigOrderUserMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - builder << ", "; - builder << R"("OrderRequestID": )"; - builder << +writer.orderRequestID(); + static SBE_CONSTEXPR std::uint16_t origOrderUserId() SBE_NOEXCEPT + { + return 9937; + } - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origOrderUserSinceVersion() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + SBE_NODISCARD bool origOrderUserInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origOrderUserSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origOrderUserEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + static SBE_CONSTEXPR char origOrderUserNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; + static SBE_CONSTEXPR char origOrderUserMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + static SBE_CONSTEXPR char origOrderUserMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + static SBE_CONSTEXPR std::size_t origOrderUserEncodingLength() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("MassActionScope": )"; - builder << '"' << writer.massActionScope() << '"'; + static SBE_CONSTEXPR std::uint64_t origOrderUserLength() SBE_NOEXCEPT + { + return 8; + } - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); + SBE_NODISCARD const char *origOrderUser() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } - builder << ", "; - builder << R"("MassCancelRequestType": )"; - builder << '"' << writer.massCancelRequestType() << '"'; + return m_buffer + m_offset + 71; + } - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; + SBE_NODISCARD char *origOrderUser() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } - builder << ", "; - builder << R"("OrdType": )"; - builder << '"' << writer.ordType() << '"'; + return m_buffer + m_offset + 71; + } - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + SBE_NODISCARD char origOrderUser(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E104]"); + } - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; + if (m_actingVersion < 8) + { + return static_cast(0); + } - builder << '}'; + char val; + std::memcpy(&val, m_buffer + m_offset + 71 + (index * 1), sizeof(char)); + return (val); + } - return builder; - } + OrderMassActionRequest529 &origOrderUser(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E105]"); + } - void skip() {} + char val = (value); + std::memcpy(m_buffer + m_offset + 71 + (index * 1), &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + std::uint64_t getOrigOrderUser(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getOrigOrderUser [E106]"); + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 71, sizeof(char) * static_cast(length)); + return length; + } + + OrderMassActionRequest529 &putOrigOrderUser(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 71, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getOrigOrderUserAsString() const + { + const char *buffer = m_buffer + m_offset + 71; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrigOrderUserAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrigOrderUserAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrigOrderUserAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 71; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + OrderMassActionRequest529 &putOrigOrderUser(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 71, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 71 + start] = 0; + } + + return *this; + } + #else + OrderMassActionRequest529 &putOrigOrderUser(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 71, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 71 + start] = 0; + } + + return *this; + } + #endif + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, OrderMassActionRequest529 _writer) +{ + OrderMassActionRequest529 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "OrderMassActionRequest529", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("OrderRequestID": )"; + builder << +writer.orderRequestID(); + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("MassActionScope": )"; + builder << '"' << writer.massActionScope() << '"'; + + builder << ", "; + builder << R"("MarketSegmentID": )"; + builder << +writer.marketSegmentID(); + + builder << ", "; + builder << R"("MassCancelRequestType": )"; + builder << '"' << writer.massCancelRequestType() << '"'; + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << ", "; + builder << R"("OrdType": )"; + builder << '"' << writer.ordType() << '"'; + + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("OrigOrderUser": )"; + builder << '"' << + writer.getOrigOrderUserAsJsonEscapedString().c_str() << '"'; + + builder << '}'; + + return builder; +} + +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderMassStatusRequest530.h b/src/lib/orderman/ilink3/generated/OrderMassStatusRequest530.h index c514ec473..ce1723e39 100644 --- a/src/lib/orderman/ilink3/generated/OrderMassStatusRequest530.h +++ b/src/lib/orderman/ilink3/generated/OrderMassStatusRequest530.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1527 +86,1659 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class OrderMassStatusRequest530 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class OrderMassStatusRequest530 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(68); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(530); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - OrderMassStatusRequest530() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - OrderMassStatusRequest530( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - OrderMassStatusRequest530(char *buffer, const std::uint64_t bufferLength) - : OrderMassStatusRequest530( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + OrderMassStatusRequest530() = default; - OrderMassStatusRequest530( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : OrderMassStatusRequest530( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + OrderMassStatusRequest530( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)68; - } + OrderMassStatusRequest530(char *buffer, const std::uint64_t bufferLength) : + OrderMassStatusRequest530(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + OrderMassStatusRequest530( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + OrderMassStatusRequest530(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)530; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(68); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(530); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "AF"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - OrderMassStatusRequest530 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = OrderMassStatusRequest530( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "AF"; + } - OrderMassStatusRequest530 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + OrderMassStatusRequest530 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = OrderMassStatusRequest530(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = OrderMassStatusRequest530( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + OrderMassStatusRequest530 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - OrderMassStatusRequest530 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = OrderMassStatusRequest530( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = OrderMassStatusRequest530( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + OrderMassStatusRequest530 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = OrderMassStatusRequest530(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + OrderMassStatusRequest530 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - OrderMassStatusRequest530 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + OrderMassStatusRequest530 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassStatusRequest530 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassStatusRequest530 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *MassStatusReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massStatusReqIDId() SBE_NOEXCEPT { - return 584; - } + static SBE_CONSTEXPR std::uint16_t massStatusReqIDId() SBE_NOEXCEPT + { + return 584; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massStatusReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massStatusReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massStatusReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massStatusReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massStatusReqIDSinceVersion(); + return m_actingVersion >= massStatusReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massStatusReqIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massStatusReqIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t massStatusReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t massStatusReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t massStatusReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t massStatusReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t massStatusReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t massStatusReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - massStatusReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t massStatusReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t massStatusReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t massStatusReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassStatusRequest530 & - massStatusReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassStatusRequest530 &massStatusReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - OrderMassStatusRequest530 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassStatusRequest530 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderMassStatusRequest530 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + OrderMassStatusRequest530 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - OrderMassStatusRequest530 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + OrderMassStatusRequest530 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - OrderMassStatusRequest530 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + OrderMassStatusRequest530 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderMassStatusRequest530 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + OrderMassStatusRequest530 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - OrderMassStatusRequest530 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + OrderMassStatusRequest530 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderMassStatusRequest530 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); - return *this; - } + OrderMassStatusRequest530 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT { - return 1151; - } + static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT + { + return 1151; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityGroupSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityGroupSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityGroupSinceVersion(); + return m_actingVersion >= securityGroupSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityGroupEncodingOffset() SBE_NOEXCEPT { - return 49; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 49; + } - static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } - SBE_NODISCARD char securityGroup(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E104]"); - } + SBE_NODISCARD char securityGroup(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); + return (val); + } - OrderMassStatusRequest530 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + OrderMassStatusRequest530 &securityGroup(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecurityGroup(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error( - "length too large for getSecurityGroup [E106]"); - } + std::uint64_t getSecurityGroup(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getSecurityGroup [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 49, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast(length)); + return length; + } - OrderMassStatusRequest530 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 6); - return *this; - } + OrderMassStatusRequest530 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 6); + return *this; + } - SBE_NODISCARD std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSecurityGroupAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityGroupAsString(); + std::string getSecurityGroupAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityGroupAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderMassStatusRequest530 &putSecurityGroup(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } + #if __cplusplus >= 201703L + OrderMassStatusRequest530 &putSecurityGroup(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } - std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } - return *this; - } -#else - OrderMassStatusRequest530 &putSecurityGroup(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } + return *this; + } + #else + OrderMassStatusRequest530 &putSecurityGroup(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } - std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 55; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 55; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 55; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 55; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 55; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 55; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 55 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 55 + (index * 1), sizeof(char)); + return (val); + } - OrderMassStatusRequest530 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + OrderMassStatusRequest530 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 55 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 55 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 55, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 55, sizeof(char) * static_cast(length)); + return length; + } - OrderMassStatusRequest530 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 55, src, sizeof(char) * 5); - return *this; - } + OrderMassStatusRequest530 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 55, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 55; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 55; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 55; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 55; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderMassStatusRequest530 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + OrderMassStatusRequest530 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 55, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 55 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 55, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 55 + start] = 0; + } - return *this; - } -#else - OrderMassStatusRequest530 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + OrderMassStatusRequest530 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 55, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 55 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 55, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 55 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSinceVersion(); + return m_actingVersion >= securityIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 60; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderMassStatusRequest530 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 60, &val, sizeof(std::int32_t)); - return *this; - } + OrderMassStatusRequest530 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 60, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char *MassStatusReqTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MassStatusReqTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t massStatusReqTypeId() SBE_NOEXCEPT { - return 585; - } + static SBE_CONSTEXPR std::uint16_t massStatusReqTypeId() SBE_NOEXCEPT + { + return 585; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - massStatusReqTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t massStatusReqTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool massStatusReqTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool massStatusReqTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= massStatusReqTypeSinceVersion(); + return m_actingVersion >= massStatusReqTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massStatusReqTypeEncodingOffset() SBE_NOEXCEPT { - return 64; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massStatusReqTypeEncodingOffset() SBE_NOEXCEPT + { + return 64; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - massStatusReqTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t massStatusReqTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassStatusReqTyp::Value - massStatusReqType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t)); - return MassStatusReqTyp::get((val)); - } + SBE_NODISCARD std::uint8_t massStatusReqTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t)); + return (val); + } - OrderMassStatusRequest530 & - massStatusReqType(const MassStatusReqTyp::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassStatusReqTyp::Value massStatusReqType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint8_t)); + return MassStatusReqTyp::get((val)); + } - SBE_NODISCARD static const char *OrdStatusReqTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassStatusRequest530 &massStatusReqType(const MassStatusReqTyp::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t ordStatusReqTypeId() SBE_NOEXCEPT { - return 5000; - } + SBE_NODISCARD static const char *OrdStatusReqTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusReqTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t ordStatusReqTypeId() SBE_NOEXCEPT + { + return 5000; + } - SBE_NODISCARD bool ordStatusReqTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusReqTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool ordStatusReqTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusReqTypeSinceVersion(); + return m_actingVersion >= ordStatusReqTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusReqTypeEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusReqTypeEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusReqTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusReqTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassStatusOrdTyp::Value ordStatusReqType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 65, sizeof(std::uint8_t)); - return MassStatusOrdTyp::get((val)); - } + SBE_NODISCARD std::uint8_t ordStatusReqTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 65, sizeof(std::uint8_t)); + return (val); + } - OrderMassStatusRequest530 & - ordStatusReqType(const MassStatusOrdTyp::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 65, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassStatusOrdTyp::Value ordStatusReqType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 65, sizeof(std::uint8_t)); + return MassStatusOrdTyp::get((val)); + } - SBE_NODISCARD static const char * - TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderMassStatusRequest530 &ordStatusReqType(const MassStatusOrdTyp::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 65, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static const char *TimeInForceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - timeInForceSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t timeInForceId() SBE_NOEXCEPT + { + return 59; + } - SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t timeInForceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool timeInForceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= timeInForceSinceVersion(); + return m_actingVersion >= timeInForceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingOffset() SBE_NOEXCEPT { - return 66; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingOffset() SBE_NOEXCEPT + { + return 66; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - timeInForceEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t timeInForceEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD MassStatusTIF::Value timeInForce() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); - return MassStatusTIF::get((val)); - } + SBE_NODISCARD std::uint8_t timeInForceRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return (val); + } - OrderMassStatusRequest530 & - timeInForce(const MassStatusTIF::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD MassStatusTIF::Value timeInForce() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return MassStatusTIF::get((val)); + } - SBE_NODISCARD static const char *MarketSegmentIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + OrderMassStatusRequest530 &timeInForce(const MassStatusTIF::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t marketSegmentIDId() SBE_NOEXCEPT { - return 1300; - } + SBE_NODISCARD static const char *MarketSegmentIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketSegmentIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t marketSegmentIDId() SBE_NOEXCEPT + { + return 1300; + } - SBE_NODISCARD bool marketSegmentIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t marketSegmentIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool marketSegmentIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= marketSegmentIDSinceVersion(); + return m_actingVersion >= marketSegmentIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketSegmentIDEncodingOffset() SBE_NOEXCEPT { - return 67; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingOffset() SBE_NOEXCEPT + { + return 67; + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - marketSegmentIDEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t marketSegmentID() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t marketSegmentID() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); + return (val); + } - OrderMassStatusRequest530 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::uint8_t)); - return *this; - } + OrderMassStatusRequest530 &marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::uint8_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - OrderMassStatusRequest530 _writer) { - OrderMassStatusRequest530 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "OrderMassStatusRequest530", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, OrderMassStatusRequest530 _writer) +{ + OrderMassStatusRequest530 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << '{'; + builder << R"("Name": "OrderMassStatusRequest530", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("MassStatusReqID": )"; - builder << +writer.massStatusReqID(); + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("MassStatusReqID": )"; + builder << +writer.massStatusReqID(); - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("MassStatusReqType": )"; - builder << '"' << writer.massStatusReqType() << '"'; + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("OrdStatusReqType": )"; - builder << '"' << writer.ordStatusReqType() << '"'; + builder << ", "; + builder << R"("MassStatusReqType": )"; + builder << '"' << writer.massStatusReqType() << '"'; - builder << ", "; - builder << R"("TimeInForce": )"; - builder << '"' << writer.timeInForce() << '"'; + builder << ", "; + builder << R"("OrdStatusReqType": )"; + builder << '"' << writer.ordStatusReqType() << '"'; - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); + builder << ", "; + builder << R"("TimeInForce": )"; + builder << '"' << writer.timeInForce() << '"'; - builder << '}'; + builder << ", "; + builder << R"("MarketSegmentID": )"; + builder << +writer.marketSegmentID(); - return builder; - } + builder << '}'; - void skip() {} + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } +void skip() +{ +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderStatus.h b/src/lib/orderman/ilink3/generated/OrderStatus.h index b19b9bc50..ac8cf1d6f 100644 --- a/src/lib/orderman/ilink3/generated/OrderStatus.h +++ b/src/lib/orderman/ilink3/generated/OrderStatus.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_ORDERSTATUS_H_ #define _ILINKBINARY_ORDERSTATUS_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,77 +25,72 @@ namespace iLinkBinary { -class OrderStatus { - public: - enum Value { - New = (char)48, - PartiallyFilled = (char)49, - Filled = (char)50, - Cancelled = (char)52, - Replaced = (char)53, - Rejected = (char)56, - Expired = (char)67, - Undefined = (char)85, - NULL_VALUE = (char)0 - }; +class OrderStatus +{ +public: + enum Value + { + New = static_cast(48), + PartiallyFilled = static_cast(49), + Filled = static_cast(50), + Cancelled = static_cast(52), + Replaced = static_cast(53), + PendingCancel = static_cast(54), + Rejected = static_cast(56), + Expired = static_cast(67), + PendingReplace = static_cast(69), + Undefined = static_cast(85), + NULL_VALUE = static_cast(0) + }; - static OrderStatus::Value get(const char value) { - switch (value) { - case 48: - return New; - case 49: - return PartiallyFilled; - case 50: - return Filled; - case 52: - return Cancelled; - case 53: - return Replaced; - case 56: - return Rejected; - case 67: - return Expired; - case 85: - return Undefined; - case 0: - return NULL_VALUE; - } + static OrderStatus::Value get(const char value) + { + switch (value) + { + case static_cast(48): return New; + case static_cast(49): return PartiallyFilled; + case static_cast(50): return Filled; + case static_cast(52): return Cancelled; + case static_cast(53): return Replaced; + case static_cast(54): return PendingCancel; + case static_cast(56): return Rejected; + case static_cast(67): return Expired; + case static_cast(69): return PendingReplace; + case static_cast(85): return Undefined; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum OrderStatus [E103]"); - } + throw std::runtime_error("unknown value for enum OrderStatus [E103]"); + } - static const char *c_str(const OrderStatus::Value value) { - switch (value) { - case New: - return "New"; - case PartiallyFilled: - return "PartiallyFilled"; - case Filled: - return "Filled"; - case Cancelled: - return "Cancelled"; - case Replaced: - return "Replaced"; - case Rejected: - return "Rejected"; - case Expired: - return "Expired"; - case Undefined: - return "Undefined"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const OrderStatus::Value value) + { + switch (value) + { + case New: return "New"; + case PartiallyFilled: return "PartiallyFilled"; + case Filled: return "Filled"; + case Cancelled: return "Cancelled"; + case Replaced: return "Replaced"; + case PendingCancel: return "PendingCancel"; + case Rejected: return "Rejected"; + case Expired: return "Expired"; + case PendingReplace: return "PendingReplace"; + case Undefined: return "Undefined"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum OrderStatus [E103]:"); - } + throw std::runtime_error("unknown value for enum OrderStatus [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, OrderStatus::Value m) { - return os << OrderStatus::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, OrderStatus::Value m) + { + return os << OrderStatus::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderStatusRequest533.h b/src/lib/orderman/ilink3/generated/OrderStatusRequest533.h index 9a0045203..ce0fa4776 100644 --- a/src/lib/orderman/ilink3/generated/OrderStatusRequest533.h +++ b/src/lib/orderman/ilink3/generated/OrderStatusRequest533.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1067 +86,1172 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class OrderStatusRequest533 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class OrderStatusRequest533 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(62); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(533); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - OrderStatusRequest533() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - OrderStatusRequest533( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - OrderStatusRequest533(char *buffer, const std::uint64_t bufferLength) - : OrderStatusRequest533( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + OrderStatusRequest533() = default; - OrderStatusRequest533( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : OrderStatusRequest533( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + OrderStatusRequest533( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)62; - } + OrderStatusRequest533(char *buffer, const std::uint64_t bufferLength) : + OrderStatusRequest533(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + OrderStatusRequest533( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + OrderStatusRequest533(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)533; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(62); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(533); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "H"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - OrderStatusRequest533 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = OrderStatusRequest533( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "H"; + } - OrderStatusRequest533 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + OrderStatusRequest533 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = OrderStatusRequest533(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = OrderStatusRequest533( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + OrderStatusRequest533 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - OrderStatusRequest533 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = OrderStatusRequest533( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = OrderStatusRequest533( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + OrderStatusRequest533 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = OrderStatusRequest533(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + OrderStatusRequest533 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - OrderStatusRequest533 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + OrderStatusRequest533 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderStatusRequest533 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + OrderStatusRequest533 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - OrdStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrdStatusReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t ordStatusReqIDId() SBE_NOEXCEPT { - return 790; - } + static SBE_CONSTEXPR std::uint16_t ordStatusReqIDId() SBE_NOEXCEPT + { + return 790; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - ordStatusReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t ordStatusReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool ordStatusReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool ordStatusReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= ordStatusReqIDSinceVersion(); + return m_actingVersion >= ordStatusReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - ordStatusReqIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t ordStatusReqIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t ordStatusReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t ordStatusReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t ordStatusReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - ordStatusReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t ordStatusReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t ordStatusReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t ordStatusReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderStatusRequest533 & - ordStatusReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + OrderStatusRequest533 &ordStatusReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - OrderStatusRequest533 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + OrderStatusRequest533 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - OrderStatusRequest533 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + OrderStatusRequest533 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - OrderStatusRequest533 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + OrderStatusRequest533 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - OrderStatusRequest533 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + OrderStatusRequest533 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderStatusRequest533 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + OrderStatusRequest533 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - OrderStatusRequest533 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + OrderStatusRequest533 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OrderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT { return 37; } + static SBE_CONSTEXPR std::uint16_t orderIDId() SBE_NOEXCEPT + { + return 37; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= orderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderIDEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t orderID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderStatusRequest533 &orderID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); - return *this; - } + OrderStatusRequest533 &orderID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 49; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 49; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 49, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 49, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - OrderStatusRequest533 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 49, &val, sizeof(std::uint64_t)); - return *this; - } + OrderStatusRequest533 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 49, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 57; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 57; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 57; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 57; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 57; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 57; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 57 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 57 + (index * 1), sizeof(char)); + return (val); + } - OrderStatusRequest533 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + OrderStatusRequest533 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 57 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 57 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 57, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 57, sizeof(char) * static_cast(length)); + return length; + } - OrderStatusRequest533 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 57, src, sizeof(char) * 5); - return *this; - } + OrderStatusRequest533 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 57, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 57; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 57; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 57; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 57; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - OrderStatusRequest533 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + OrderStatusRequest533 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 57, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 57 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 57, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 57 + start] = 0; + } - return *this; - } -#else - OrderStatusRequest533 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + OrderStatusRequest533 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 57, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 57 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 57, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 57 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - OrderStatusRequest533 _writer) { - OrderStatusRequest533 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "OrderStatusRequest533", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, OrderStatusRequest533 _writer) +{ + OrderStatusRequest533 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << '{'; + builder << R"("Name": "OrderStatusRequest533", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("OrdStatusReqID": )"; - builder << +writer.ordStatusReqID(); + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("OrdStatusReqID": )"; + builder << +writer.ordStatusReqID(); - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("OrderID": )"; - builder << +writer.orderID(); + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("OrderID": )"; + builder << +writer.orderID(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << '}'; + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - return builder; - } + builder << '}'; - void skip() {} + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } +void skip() +{ +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderType.h b/src/lib/orderman/ilink3/generated/OrderType.h index afcdcdeb5..58deb73c5 100644 --- a/src/lib/orderman/ilink3/generated/OrderType.h +++ b/src/lib/orderman/ilink3/generated/OrderType.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_ORDERTYPE_H_ #define _ILINKBINARY_ORDERTYPE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,57 +25,54 @@ namespace iLinkBinary { -class OrderType { - public: - enum Value { - MarketWithProtection = (char)49, - Limit = (char)50, - StopLimit = (char)52, - MarketWithLeftoverAsLimit = (char)75, - NULL_VALUE = (char)0 - }; +class OrderType +{ +public: + enum Value + { + MarketWithProtection = static_cast(49), + Limit = static_cast(50), + StopLimit = static_cast(52), + MarketWithLeftoverAsLimit = static_cast(75), + NULL_VALUE = static_cast(48) + }; - static OrderType::Value get(const char value) { - switch (value) { - case 49: - return MarketWithProtection; - case 50: - return Limit; - case 52: - return StopLimit; - case 75: - return MarketWithLeftoverAsLimit; - case 0: - return NULL_VALUE; - } + static OrderType::Value get(const char value) + { + switch (value) + { + case static_cast(49): return MarketWithProtection; + case static_cast(50): return Limit; + case static_cast(52): return StopLimit; + case static_cast(75): return MarketWithLeftoverAsLimit; + case static_cast(48): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum OrderType [E103]"); - } + throw std::runtime_error("unknown value for enum OrderType [E103]"); + } - static const char *c_str(const OrderType::Value value) { - switch (value) { - case MarketWithProtection: - return "MarketWithProtection"; - case Limit: - return "Limit"; - case StopLimit: - return "StopLimit"; - case MarketWithLeftoverAsLimit: - return "MarketWithLeftoverAsLimit"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const OrderType::Value value) + { + switch (value) + { + case MarketWithProtection: return "MarketWithProtection"; + case Limit: return "Limit"; + case StopLimit: return "StopLimit"; + case MarketWithLeftoverAsLimit: return "MarketWithLeftoverAsLimit"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum OrderType [E103]:"); - } + throw std::runtime_error("unknown value for enum OrderType [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, OrderType::Value m) { - return os << OrderType::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, OrderType::Value m) + { + return os << OrderType::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/OrderTypeReq.h b/src/lib/orderman/ilink3/generated/OrderTypeReq.h index 2827ebce8..dfac729db 100644 --- a/src/lib/orderman/ilink3/generated/OrderTypeReq.h +++ b/src/lib/orderman/ilink3/generated/OrderTypeReq.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_ORDERTYPEREQ_H_ #define _ILINKBINARY_ORDERTYPEREQ_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,62 +25,57 @@ namespace iLinkBinary { -class OrderTypeReq { - public: - enum Value { - MarketwithProtection = (char)49, - Limit = (char)50, - StopwithProtection = (char)51, - StopLimit = (char)52, - MarketWithLeftoverAsLimit = (char)75, - NULL_VALUE = (char)0 - }; +class OrderTypeReq +{ +public: + enum Value + { + MarketwithProtection = static_cast(49), + Limit = static_cast(50), + StopwithProtection = static_cast(51), + StopLimit = static_cast(52), + MarketWithLeftoverAsLimit = static_cast(75), + NULL_VALUE = static_cast(0) + }; - static OrderTypeReq::Value get(const char value) { - switch (value) { - case 49: - return MarketwithProtection; - case 50: - return Limit; - case 51: - return StopwithProtection; - case 52: - return StopLimit; - case 75: - return MarketWithLeftoverAsLimit; - case 0: - return NULL_VALUE; - } + static OrderTypeReq::Value get(const char value) + { + switch (value) + { + case static_cast(49): return MarketwithProtection; + case static_cast(50): return Limit; + case static_cast(51): return StopwithProtection; + case static_cast(52): return StopLimit; + case static_cast(75): return MarketWithLeftoverAsLimit; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum OrderTypeReq [E103]"); - } + throw std::runtime_error("unknown value for enum OrderTypeReq [E103]"); + } - static const char *c_str(const OrderTypeReq::Value value) { - switch (value) { - case MarketwithProtection: - return "MarketwithProtection"; - case Limit: - return "Limit"; - case StopwithProtection: - return "StopwithProtection"; - case StopLimit: - return "StopLimit"; - case MarketWithLeftoverAsLimit: - return "MarketWithLeftoverAsLimit"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const OrderTypeReq::Value value) + { + switch (value) + { + case MarketwithProtection: return "MarketwithProtection"; + case Limit: return "Limit"; + case StopwithProtection: return "StopwithProtection"; + case StopLimit: return "StopLimit"; + case MarketWithLeftoverAsLimit: return "MarketWithLeftoverAsLimit"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum OrderTypeReq [E103]:"); - } + throw std::runtime_error("unknown value for enum OrderTypeReq [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, OrderTypeReq::Value m) { - return os << OrderTypeReq::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, OrderTypeReq::Value m) + { + return os << OrderTypeReq::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/PRICE9.h b/src/lib/orderman/ilink3/generated/PRICE9.h index 2de1a9ed5..8793e1ae2 100644 --- a/src/lib/orderman/ilink3/generated/PRICE9.h +++ b/src/lib/orderman/ilink3/generated/PRICE9.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,214 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace iLinkBinary { -class PRICE9 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class PRICE9 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - PRICE9() = default; + PRICE9() = default; - PRICE9( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_actingVersion(actingVersion) { - if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 8) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + PRICE9( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_actingVersion(actingVersion) + { + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 8) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - PRICE9( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : PRICE9(buffer, 0, bufferLength, actingVersion) {} + PRICE9( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + PRICE9(buffer, 0, bufferLength, actingVersion) + { + } - PRICE9(char *buffer, const std::uint64_t bufferLength) - : PRICE9(buffer, 0, bufferLength, sbeSchemaVersion()) {} + PRICE9( + char *buffer, + const std::uint64_t bufferLength) : + PRICE9(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - PRICE9 &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = PRICE9(buffer, offset, bufferLength, actingVersion); - } + PRICE9 &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = PRICE9(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static const char * - mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mantissaSinceVersion(); + return m_actingVersion >= mantissaSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mantissaEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mantissaEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT64; - } + static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT64; + } - static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT { - return -9223372036854775807L; - } + static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT + { + return INT64_C(-9223372036854775807); + } - static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT { - return 9223372036854775807L; - } + static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT + { + return INT64_C(9223372036854775807); + } - static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::int64_t mantissa() const SBE_NOEXCEPT { - std::int64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::int64_t mantissa() const SBE_NOEXCEPT + { + std::int64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PRICE9 &mantissa(const std::int64_t value) SBE_NOEXCEPT { - std::int64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int64_t)); - return *this; - } + PRICE9 &mantissa(const std::int64_t value) SBE_NOEXCEPT + { + std::int64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int64_t)); + return *this; + } - SBE_NODISCARD static const char * - exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t exponentId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t exponentId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - exponentSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t exponentSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool exponentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool exponentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= exponentSinceVersion(); + return m_actingVersion >= exponentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - exponentEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t exponentEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } + static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } - static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT { - return (std::int8_t)-9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT + { + return static_cast(-9); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, PRICE9 writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, PRICE9 writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/PRICENULL9.h b/src/lib/orderman/ilink3/generated/PRICENULL9.h index 33492e2ff..c3b21389e 100644 --- a/src/lib/orderman/ilink3/generated/PRICENULL9.h +++ b/src/lib/orderman/ilink3/generated/PRICENULL9.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,214 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace iLinkBinary { -class PRICENULL9 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class PRICENULL9 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - PRICENULL9() = default; + PRICENULL9() = default; - PRICENULL9( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_actingVersion(actingVersion) { - if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 8) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + PRICENULL9( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_actingVersion(actingVersion) + { + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + 8) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - PRICENULL9( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : PRICENULL9(buffer, 0, bufferLength, actingVersion) {} + PRICENULL9( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + PRICENULL9(buffer, 0, bufferLength, actingVersion) + { + } - PRICENULL9(char *buffer, const std::uint64_t bufferLength) - : PRICENULL9(buffer, 0, bufferLength, sbeSchemaVersion()) {} + PRICENULL9( + char *buffer, + const std::uint64_t bufferLength) : + PRICENULL9(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - PRICENULL9 &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = PRICENULL9(buffer, offset, bufferLength, actingVersion); - } + PRICENULL9 &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = PRICENULL9(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD static const char * - mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *mantissaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mantissaSinceVersion(); + return m_actingVersion >= mantissaSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mantissaEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mantissaEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT { - return 9223372036854775807L; - } + static SBE_CONSTEXPR std::int64_t mantissaNullValue() SBE_NOEXCEPT + { + return INT64_C(9223372036854775807); + } - static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT { - return -9223372036854775807L; - } + static SBE_CONSTEXPR std::int64_t mantissaMinValue() SBE_NOEXCEPT + { + return INT64_C(-9223372036854775807); + } - static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT { - return 9223372036854775807L; - } + static SBE_CONSTEXPR std::int64_t mantissaMaxValue() SBE_NOEXCEPT + { + return INT64_C(9223372036854775807); + } - static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t mantissaEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::int64_t mantissa() const SBE_NOEXCEPT { - std::int64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::int64_t mantissa() const SBE_NOEXCEPT + { + std::int64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PRICENULL9 &mantissa(const std::int64_t value) SBE_NOEXCEPT { - std::int64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int64_t)); - return *this; - } + PRICENULL9 &mantissa(const std::int64_t value) SBE_NOEXCEPT + { + std::int64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int64_t)); + return *this; + } - SBE_NODISCARD static const char * - exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t exponentId() SBE_NOEXCEPT { return -1; } + static SBE_CONSTEXPR std::uint16_t exponentId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - exponentSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t exponentSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool exponentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool exponentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= exponentSinceVersion(); + return m_actingVersion >= exponentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - exponentEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t exponentEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } + static SBE_CONSTEXPR std::int8_t exponentNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } - static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t exponentMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t exponentMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t exponentEncodingLength() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT { - return (std::int8_t)-9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT + { + return static_cast(-9); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, PRICENULL9 writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, PRICENULL9 writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/PartyDetailRole.h b/src/lib/orderman/ilink3/generated/PartyDetailRole.h index 8422117db..23c884181 100644 --- a/src/lib/orderman/ilink3/generated/PartyDetailRole.h +++ b/src/lib/orderman/ilink3/generated/PartyDetailRole.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_PARTYDETAILROLE_H_ #define _ILINKBINARY_PARTYDETAILROLE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,63 +25,57 @@ namespace iLinkBinary { -class PartyDetailRole { - public: - enum Value { - ExecutingFirm = (std::uint16_t)1, - CustomerAccount = (std::uint16_t)24, - TakeUpFirm = (std::uint16_t)96, - Operator = (std::uint16_t)118, - TakeUpAccount = (std::uint16_t)1000, - NULL_VALUE = (std::uint16_t)65535 - }; +class PartyDetailRole +{ +public: + enum Value + { + ExecutingFirm = static_cast(1), + CustomerAccount = static_cast(24), + TakeUpFirm = static_cast(96), + Operator = static_cast(118), + TakeUpAccount = static_cast(1000), + NULL_VALUE = static_cast(65535) + }; - static PartyDetailRole::Value get(const std::uint16_t value) { - switch (value) { - case 1: - return ExecutingFirm; - case 24: - return CustomerAccount; - case 96: - return TakeUpFirm; - case 118: - return Operator; - case 1000: - return TakeUpAccount; - case 65535: - return NULL_VALUE; - } + static PartyDetailRole::Value get(const std::uint16_t value) + { + switch (value) + { + case static_cast(1): return ExecutingFirm; + case static_cast(24): return CustomerAccount; + case static_cast(96): return TakeUpFirm; + case static_cast(118): return Operator; + case static_cast(1000): return TakeUpAccount; + case static_cast(65535): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum PartyDetailRole [E103]"); - } + throw std::runtime_error("unknown value for enum PartyDetailRole [E103]"); + } - static const char *c_str(const PartyDetailRole::Value value) { - switch (value) { - case ExecutingFirm: - return "ExecutingFirm"; - case CustomerAccount: - return "CustomerAccount"; - case TakeUpFirm: - return "TakeUpFirm"; - case Operator: - return "Operator"; - case TakeUpAccount: - return "TakeUpAccount"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const PartyDetailRole::Value value) + { + switch (value) + { + case ExecutingFirm: return "ExecutingFirm"; + case CustomerAccount: return "CustomerAccount"; + case TakeUpFirm: return "TakeUpFirm"; + case Operator: return "Operator"; + case TakeUpAccount: return "TakeUpAccount"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum PartyDetailRole [E103]:"); - } + throw std::runtime_error("unknown value for enum PartyDetailRole [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, PartyDetailRole::Value m) { - return os << PartyDetailRole::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, PartyDetailRole::Value m) + { + return os << PartyDetailRole::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/PartyDetailsDefinitionRequest518.h b/src/lib/orderman/ilink3/generated/PartyDetailsDefinitionRequest518.h index efb591af7..005a90491 100644 --- a/src/lib/orderman/ilink3/generated/PartyDetailsDefinitionRequest518.h +++ b/src/lib/orderman/ilink3/generated/PartyDetailsDefinitionRequest518.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2624 +86,2821 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class PartyDetailsDefinitionRequest518 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class PartyDetailsDefinitionRequest518 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(147); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(518); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - PartyDetailsDefinitionRequest518() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - PartyDetailsDefinitionRequest518( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - PartyDetailsDefinitionRequest518( - char *buffer, const std::uint64_t bufferLength) - : PartyDetailsDefinitionRequest518( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + PartyDetailsDefinitionRequest518() = default; - PartyDetailsDefinitionRequest518( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : PartyDetailsDefinitionRequest518( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + PartyDetailsDefinitionRequest518( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)147; - } + PartyDetailsDefinitionRequest518(char *buffer, const std::uint64_t bufferLength) : + PartyDetailsDefinitionRequest518(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + PartyDetailsDefinitionRequest518( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + PartyDetailsDefinitionRequest518(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)518; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(147); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(518); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "CX"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - PartyDetailsDefinitionRequest518 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = PartyDetailsDefinitionRequest518( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "CX"; + } - PartyDetailsDefinitionRequest518 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + PartyDetailsDefinitionRequest518 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = PartyDetailsDefinitionRequest518(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = PartyDetailsDefinitionRequest518( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + PartyDetailsDefinitionRequest518 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - PartyDetailsDefinitionRequest518 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = PartyDetailsDefinitionRequest518( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = PartyDetailsDefinitionRequest518( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + PartyDetailsDefinitionRequest518 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = PartyDetailsDefinitionRequest518(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + PartyDetailsDefinitionRequest518 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - PartyDetailsDefinitionRequest518 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + PartyDetailsDefinitionRequest518 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequest518 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequest518 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequest518 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequest518 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *ListUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ListUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t listUpdateActionId() SBE_NOEXCEPT { - return 1324; - } + static SBE_CONSTEXPR std::uint16_t listUpdateActionId() SBE_NOEXCEPT + { + return 1324; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - listUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t listUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool listUpdateActionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool listUpdateActionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= listUpdateActionSinceVersion(); + return m_actingVersion >= listUpdateActionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - listUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t listUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - listUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t listUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ListUpdAct::Value listUpdateAction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(char)); - return ListUpdAct::get((val)); - } + SBE_NODISCARD char listUpdateActionRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequest518 & - listUpdateAction(const ListUpdAct::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ListUpdAct::Value listUpdateAction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(char)); + return ListUpdAct::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequest518 &listUpdateAction(const ListUpdAct::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - PartyDetailsDefinitionRequest518 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + PartyDetailsDefinitionRequest518 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MemoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MemoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t memoId() SBE_NOEXCEPT { return 5149; } + static SBE_CONSTEXPR std::uint16_t memoId() SBE_NOEXCEPT + { + return 5149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - memoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t memoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool memoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool memoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= memoSinceVersion(); + return m_actingVersion >= memoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - memoEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t memoEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char memoNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char memoNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char memoMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char memoMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char memoMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char memoMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t memoEncodingLength() SBE_NOEXCEPT { - return 75; - } + static SBE_CONSTEXPR std::size_t memoEncodingLength() SBE_NOEXCEPT + { + return 75; + } - static SBE_CONSTEXPR std::uint64_t memoLength() SBE_NOEXCEPT { return 75; } + static SBE_CONSTEXPR std::uint64_t memoLength() SBE_NOEXCEPT + { + return 75; + } - SBE_NODISCARD const char *memo() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *memo() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *memo() SBE_NOEXCEPT { return m_buffer + m_offset + 21; } + SBE_NODISCARD char *memo() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char memo(const std::uint64_t index) const { - if (index >= 75) { - throw std::runtime_error("index out of range for memo [E104]"); - } + SBE_NODISCARD char memo(const std::uint64_t index) const + { + if (index >= 75) + { + throw std::runtime_error("index out of range for memo [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequest518 & - memo(const std::uint64_t index, const char value) { - if (index >= 75) { - throw std::runtime_error("index out of range for memo [E105]"); - } + PartyDetailsDefinitionRequest518 &memo(const std::uint64_t index, const char value) + { + if (index >= 75) + { + throw std::runtime_error("index out of range for memo [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getMemo(char *const dst, const std::uint64_t length) const { - if (length > 75) { - throw std::runtime_error("length too large for getMemo [E106]"); - } + std::uint64_t getMemo(char *const dst, const std::uint64_t length) const + { + if (length > 75) + { + throw std::runtime_error("length too large for getMemo [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - PartyDetailsDefinitionRequest518 & - putMemo(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 75); - return *this; - } + PartyDetailsDefinitionRequest518 &putMemo(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 75); + return *this; + } - SBE_NODISCARD std::string getMemoAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getMemoAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 75 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 75 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getMemoAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMemoAsString(); + std::string getMemoAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMemoAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getMemoAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getMemoAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 75 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 75 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - PartyDetailsDefinitionRequest518 &putMemo(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 75) { - throw std::runtime_error("string too large for putMemo [E106]"); - } + #if __cplusplus >= 201703L + PartyDetailsDefinitionRequest518 &putMemo(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 75) + { + throw std::runtime_error("string too large for putMemo [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 75; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 75; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - PartyDetailsDefinitionRequest518 &putMemo(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 75) { - throw std::runtime_error("string too large for putMemo [E106]"); - } + return *this; + } + #else + PartyDetailsDefinitionRequest518 &putMemo(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 75) + { + throw std::runtime_error("string too large for putMemo [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 75; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 75; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t avgPxGroupIDId() SBE_NOEXCEPT { - return 1731; - } + static SBE_CONSTEXPR std::uint16_t avgPxGroupIDId() SBE_NOEXCEPT + { + return 1731; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - avgPxGroupIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t avgPxGroupIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool avgPxGroupIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool avgPxGroupIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= avgPxGroupIDSinceVersion(); + return m_actingVersion >= avgPxGroupIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - avgPxGroupIDEncodingOffset() SBE_NOEXCEPT { - return 96; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingOffset() SBE_NOEXCEPT + { + return 96; + } - static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t avgPxGroupIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t avgPxGroupIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *avgPxGroupID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 96; - } + SBE_NODISCARD const char *avgPxGroupID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 96; + } - SBE_NODISCARD char *avgPxGroupID() SBE_NOEXCEPT { - return m_buffer + m_offset + 96; - } + SBE_NODISCARD char *avgPxGroupID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 96; + } - SBE_NODISCARD char avgPxGroupID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for avgPxGroupID [E104]"); - } + SBE_NODISCARD char avgPxGroupID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for avgPxGroupID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 96 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 96 + (index * 1), sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequest518 & - avgPxGroupID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for avgPxGroupID [E105]"); - } + PartyDetailsDefinitionRequest518 &avgPxGroupID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for avgPxGroupID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 96 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 96 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getAvgPxGroupID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getAvgPxGroupID [E106]"); - } + std::uint64_t getAvgPxGroupID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getAvgPxGroupID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 96, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 96, sizeof(char) * static_cast(length)); + return length; + } - PartyDetailsDefinitionRequest518 & - putAvgPxGroupID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 96, src, sizeof(char) * 20); - return *this; - } + PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 96, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getAvgPxGroupIDAsString() const { - const char *buffer = m_buffer + m_offset + 96; - size_t length = 0; + SBE_NODISCARD std::string getAvgPxGroupIDAsString() const + { + const char *buffer = m_buffer + m_offset + 96; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getAvgPxGroupIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAvgPxGroupIDAsString(); + std::string getAvgPxGroupIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAvgPxGroupIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 96; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 96; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - PartyDetailsDefinitionRequest518 & - putAvgPxGroupID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putAvgPxGroupID [E106]"); - } + #if __cplusplus >= 201703L + PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); + } - std::memcpy(m_buffer + m_offset + 96, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 96 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 96, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 96 + start] = 0; + } - return *this; - } -#else - PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putAvgPxGroupID [E106]"); - } + return *this; + } + #else + PartyDetailsDefinitionRequest518 &putAvgPxGroupID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); + } - std::memcpy(m_buffer + m_offset + 96, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 96 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 96, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 96 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *SelfMatchPreventionIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SelfMatchPreventionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t selfMatchPreventionIDId() SBE_NOEXCEPT { - return 2362; - } + static SBE_CONSTEXPR std::uint16_t selfMatchPreventionIDId() SBE_NOEXCEPT + { + return 2362; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool selfMatchPreventionIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool selfMatchPreventionIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= selfMatchPreventionIDSinceVersion(); + return m_actingVersion >= selfMatchPreventionIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - selfMatchPreventionIDEncodingOffset() SBE_NOEXCEPT { - return 116; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingOffset() SBE_NOEXCEPT + { + return 116; + } - static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t selfMatchPreventionID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t selfMatchPreventionID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 116, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequest518 & - selfMatchPreventionID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequest518 &selfMatchPreventionID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 116, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cmtaGiveupCDId() SBE_NOEXCEPT { - return 9708; - } + static SBE_CONSTEXPR std::uint16_t cmtaGiveupCDId() SBE_NOEXCEPT + { + return 9708; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cmtaGiveupCDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cmtaGiveupCDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cmtaGiveupCDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cmtaGiveupCDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cmtaGiveupCDSinceVersion(); + return m_actingVersion >= cmtaGiveupCDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cmtaGiveupCDEncodingOffset() SBE_NOEXCEPT { - return 124; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cmtaGiveupCDEncodingOffset() SBE_NOEXCEPT + { + return 124; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cmtaGiveupCDEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cmtaGiveupCDEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 124, sizeof(char)); - return CmtaGiveUpCD::get((val)); - } + SBE_NODISCARD char cmtaGiveupCDRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequest518 & - cmtaGiveupCD(const CmtaGiveUpCD::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 124, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 124, sizeof(char)); + return CmtaGiveUpCD::get((val)); + } - SBE_NODISCARD static const char *CustOrderCapacityMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequest518 &cmtaGiveupCD(const CmtaGiveUpCD::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 124, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t custOrderCapacityId() SBE_NOEXCEPT { - return 582; - } + SBE_NODISCARD static const char *CustOrderCapacityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - custOrderCapacitySinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t custOrderCapacityId() SBE_NOEXCEPT + { + return 582; + } - SBE_NODISCARD bool custOrderCapacityInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t custOrderCapacitySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool custOrderCapacityInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= custOrderCapacitySinceVersion(); + return m_actingVersion >= custOrderCapacitySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderCapacityEncodingOffset() SBE_NOEXCEPT { - return 125; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderCapacityEncodingOffset() SBE_NOEXCEPT + { + return 125; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderCapacityEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderCapacityEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD CustOrderCapacity::Value - custOrderCapacity() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 125, sizeof(std::uint8_t)); - return CustOrderCapacity::get((val)); - } + SBE_NODISCARD std::uint8_t custOrderCapacityRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 125, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequest518 & - custOrderCapacity(const CustOrderCapacity::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 125, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD CustOrderCapacity::Value custOrderCapacity() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 125, sizeof(std::uint8_t)); + return CustOrderCapacity::get((val)); + } - SBE_NODISCARD static const char *ClearingAccountTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequest518 &custOrderCapacity(const CustOrderCapacity::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 125, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t clearingAccountTypeId() SBE_NOEXCEPT { - return 1816; - } + SBE_NODISCARD static const char *ClearingAccountTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearingAccountTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t clearingAccountTypeId() SBE_NOEXCEPT + { + return 1816; + } - SBE_NODISCARD bool clearingAccountTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearingAccountTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clearingAccountTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearingAccountTypeSinceVersion(); + return m_actingVersion >= clearingAccountTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingAccountTypeEncodingOffset() SBE_NOEXCEPT { - return 126; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingAccountTypeEncodingOffset() SBE_NOEXCEPT + { + return 126; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingAccountTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingAccountTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ClearingAcctType::Value - clearingAccountType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 126, sizeof(std::uint8_t)); - return ClearingAcctType::get((val)); - } + SBE_NODISCARD std::uint8_t clearingAccountTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 126, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequest518 & - clearingAccountType(const ClearingAcctType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 126, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ClearingAcctType::Value clearingAccountType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 126, sizeof(std::uint8_t)); + return ClearingAcctType::get((val)); + } - SBE_NODISCARD static const char *SelfMatchPreventionInstructionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequest518 &clearingAccountType(const ClearingAcctType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 126, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t - selfMatchPreventionInstructionId() SBE_NOEXCEPT { - return 8000; - } + SBE_NODISCARD static const char *SelfMatchPreventionInstructionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionInstructionSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t selfMatchPreventionInstructionId() SBE_NOEXCEPT + { + return 8000; + } - SBE_NODISCARD bool - selfMatchPreventionInstructionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t selfMatchPreventionInstructionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool selfMatchPreventionInstructionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= selfMatchPreventionInstructionSinceVersion(); + return m_actingVersion >= selfMatchPreventionInstructionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - selfMatchPreventionInstructionEncodingOffset() SBE_NOEXCEPT { - return 127; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t selfMatchPreventionInstructionEncodingOffset() SBE_NOEXCEPT + { + return 127; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - selfMatchPreventionInstructionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t selfMatchPreventionInstructionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SMPI::Value - selfMatchPreventionInstruction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 127, sizeof(char)); - return SMPI::get((val)); - } + SBE_NODISCARD char selfMatchPreventionInstructionRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 127, sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequest518 & - selfMatchPreventionInstruction(const SMPI::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 127, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD SMPI::Value selfMatchPreventionInstruction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 127, sizeof(char)); + return SMPI::get((val)); + } - SBE_NODISCARD static const char * - AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequest518 &selfMatchPreventionInstruction(const SMPI::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 127, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t avgPxIndicatorId() SBE_NOEXCEPT { - return 819; - } + SBE_NODISCARD static const char *AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - avgPxIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t avgPxIndicatorId() SBE_NOEXCEPT + { + return 819; + } - SBE_NODISCARD bool avgPxIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t avgPxIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool avgPxIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= avgPxIndicatorSinceVersion(); + return m_actingVersion >= avgPxIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - avgPxIndicatorEncodingOffset() SBE_NOEXCEPT { - return 128; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t avgPxIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 128; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - avgPxIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t avgPxIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 128, sizeof(std::uint8_t)); - return AvgPxInd::get((val)); - } + SBE_NODISCARD std::uint8_t avgPxIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 128, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequest518 & - avgPxIndicator(const AvgPxInd::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 128, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 128, sizeof(std::uint8_t)); + return AvgPxInd::get((val)); + } - SBE_NODISCARD static const char *ClearingTradePriceTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequest518 &avgPxIndicator(const AvgPxInd::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 128, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t clearingTradePriceTypeId() SBE_NOEXCEPT { - return 1598; - } + SBE_NODISCARD static const char *ClearingTradePriceTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearingTradePriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t clearingTradePriceTypeId() SBE_NOEXCEPT + { + return 1598; + } - SBE_NODISCARD bool clearingTradePriceTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearingTradePriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clearingTradePriceTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearingTradePriceTypeSinceVersion(); + return m_actingVersion >= clearingTradePriceTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingTradePriceTypeEncodingOffset() SBE_NOEXCEPT { - return 129; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingTradePriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 129; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingTradePriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingTradePriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SLEDS::Value clearingTradePriceType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 129, sizeof(std::uint8_t)); - return SLEDS::get((val)); - } + SBE_NODISCARD std::uint8_t clearingTradePriceTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 129, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequest518 & - clearingTradePriceType(const SLEDS::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 129, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SLEDS::Value clearingTradePriceType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 129, sizeof(std::uint8_t)); + return SLEDS::get((val)); + } - SBE_NODISCARD static const char *CustOrderHandlingInstMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequest518 &clearingTradePriceType(const SLEDS::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 129, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t custOrderHandlingInstId() SBE_NOEXCEPT { - return 1031; - } + SBE_NODISCARD static const char *CustOrderHandlingInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - custOrderHandlingInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t custOrderHandlingInstId() SBE_NOEXCEPT + { + return 1031; + } - SBE_NODISCARD bool custOrderHandlingInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t custOrderHandlingInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool custOrderHandlingInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= custOrderHandlingInstSinceVersion(); + return m_actingVersion >= custOrderHandlingInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderHandlingInstEncodingOffset() SBE_NOEXCEPT { - return 130; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderHandlingInstEncodingOffset() SBE_NOEXCEPT + { + return 130; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderHandlingInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderHandlingInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD CustOrdHandlInst::Value - custOrderHandlingInst() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 130, sizeof(char)); - return CustOrdHandlInst::get((val)); - } + SBE_NODISCARD char custOrderHandlingInstRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 130, sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequest518 & - custOrderHandlingInst(const CustOrdHandlInst::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 130, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD CustOrdHandlInst::Value custOrderHandlingInst() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 130, sizeof(char)); + return CustOrdHandlInst::get((val)); + } - SBE_NODISCARD static const char * - ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + PartyDetailsDefinitionRequest518 &custOrderHandlingInst(const CustOrdHandlInst::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 130, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t executorId() SBE_NOEXCEPT { return 5290; } + SBE_NODISCARD static const char *ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t executorId() SBE_NOEXCEPT + { + return 5290; + } - SBE_NODISCARD bool executorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool executorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executorSinceVersion(); + return m_actingVersion >= executorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executorEncodingOffset() SBE_NOEXCEPT { - return 131; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executorEncodingOffset() SBE_NOEXCEPT + { + return 131; + } - static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t executor() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 131, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t executor() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 131, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequest518 & - executor(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 131, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequest518 &executor(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 131, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t iDMShortCodeId() SBE_NOEXCEPT { - return 36023; - } + static SBE_CONSTEXPR std::uint16_t iDMShortCodeId() SBE_NOEXCEPT + { + return 36023; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - iDMShortCodeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t iDMShortCodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool iDMShortCodeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool iDMShortCodeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= iDMShortCodeSinceVersion(); + return m_actingVersion >= iDMShortCodeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - iDMShortCodeEncodingOffset() SBE_NOEXCEPT { - return 139; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingOffset() SBE_NOEXCEPT + { + return 139; + } - static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t iDMShortCode() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 139, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t iDMShortCode() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 139, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequest518 & - iDMShortCode(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 139, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequest518 &iDMShortCode(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 139, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - NoPartyUpdatesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *NoPartyUpdatesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t noPartyUpdatesId() SBE_NOEXCEPT { - return 1676; - } + static SBE_CONSTEXPR std::uint16_t noPartyUpdatesId() SBE_NOEXCEPT + { + return 1676; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noPartyUpdatesSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noPartyUpdatesSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noPartyUpdatesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noPartyUpdatesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noPartyUpdatesSinceVersion(); + return m_actingVersion >= noPartyUpdatesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - noPartyUpdatesEncodingOffset() SBE_NOEXCEPT { - return 147; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t noPartyUpdatesEncodingOffset() SBE_NOEXCEPT + { + return 147; + } - static SBE_CONSTEXPR std::uint8_t noPartyUpdatesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t noPartyUpdatesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - noPartyUpdatesEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t noPartyUpdatesEncodingLength() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint8_t - noPartyUpdates() SBE_NOEXCEPT { - return (std::uint8_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint8_t noPartyUpdates() SBE_NOEXCEPT + { + return static_cast(1); + } - class NoPartyDetails { + class NoPartyDetails + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(22)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 22; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 22; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoPartyDetails &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *PartyDetailIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailIDId() SBE_NOEXCEPT + { + return 1691; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t partyDetailIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *partyDetailID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char *partyDetailID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char partyDetailID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for partyDetailID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } + + NoPartyDetails &partyDetailID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for partyDetailID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getPartyDetailID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getPartyDetailID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoPartyDetails &putPartyDetailID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getPartyDetailIDAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getPartyDetailIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getPartyDetailIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getPartyDetailIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoPartyDetails &putPartyDetailID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putPartyDetailID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoPartyDetails &putPartyDetailID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putPartyDetailID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailIDSourceId() SBE_NOEXCEPT + { + return 1692; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailIDSourceLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *partyDetailIDSource() const + { + static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 }; + + return (const char *)partyDetailIDSourceValues; + } + + SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const + { + static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 }; + + return (char)partyDetailIDSourceValues[index]; + } + + std::uint64_t getPartyDetailIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t partyDetailIDSourceValues[] = { 67 }; + std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) ? length : sizeof(partyDetailIDSourceValues); + + std::memcpy(dst, partyDetailIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getPartyDetailIDSourceAsString() const + { + static const std::uint8_t PartyDetailIDSourceValues[] = { 67 }; + + return std::string((const char *)PartyDetailIDSourceValues, 1); + } + + std::string getPartyDetailIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getPartyDetailIDSourceAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *PartyDetailRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailRoleId() SBE_NOEXCEPT + { + return 1693; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailRoleSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailRoleInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailRoleSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailRoleEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailRoleEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t partyDetailRoleRaw() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + SBE_NODISCARD PartyDetailRole::Value partyDetailRole() const + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); + return PartyDetailRole::get(SBE_LITTLE_ENDIAN_ENCODE_16(val)); + } + + NoPartyDetails &partyDetailRole(const PartyDetailRole::Value value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint16_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoPartyDetails writer) + { + builder << '{'; + builder << R"("PartyDetailID": )"; + builder << '"' << + writer.getPartyDetailIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailRole": )"; + builder << '"' << writer.partyDetailRole() << '"'; + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)22); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 22; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoPartyDetails m_noPartyDetails; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 22; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoPartyDetailsId() SBE_NOEXCEPT + { + return 1671; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoPartyDetails &noPartyDetails() + { + m_noPartyDetails.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noPartyDetails; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoPartyDetails &noPartyDetailsCount(const std::uint8_t count) + { + m_noPartyDetails.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noPartyDetails; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noPartyDetailsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoPartyDetails &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *PartyDetailIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailIDId() SBE_NOEXCEPT { - return 1691; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noPartyDetailsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailIDSinceVersion(); + return m_actingVersion >= noPartyDetailsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - partyDetailIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t partyDetailIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *partyDetailID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *partyDetailID() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char partyDetailID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error( - "index out of range for partyDetailID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoPartyDetails & - partyDetailID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error( - "index out of range for partyDetailID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getPartyDetailID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getPartyDetailID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoPartyDetails &putPartyDetailID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getPartyDetailIDAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getPartyDetailIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getPartyDetailIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getPartyDetailIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoPartyDetails &putPartyDetailID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putPartyDetailID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoPartyDetails &putPartyDetailID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putPartyDetailID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailIDSourceMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailIDSourceId() SBE_NOEXCEPT { - return 1692; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailIDSourceEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - partyDetailIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailIDSourceLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *partyDetailIDSource() const { - static const std::uint8_t partyDetailIDSourceValues[] = {67}; - - return (const char *)partyDetailIDSourceValues; - } - - SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const { - static const std::uint8_t partyDetailIDSourceValues[] = {67}; - - return (char)partyDetailIDSourceValues[index]; - } - - std::uint64_t - getPartyDetailIDSource(char *dst, const std::uint64_t length) const { - static std::uint8_t partyDetailIDSourceValues[] = {67}; - std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) - ? length - : sizeof(partyDetailIDSourceValues); - - std::memcpy( - dst, partyDetailIDSourceValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getPartyDetailIDSourceAsString() const { - static const std::uint8_t PartyDetailIDSourceValues[] = {67}; - - return std::string((const char *)PartyDetailIDSourceValues, 1); - } - - std::string getPartyDetailIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getPartyDetailIDSourceAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char *PartyDetailRoleMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailRoleId() SBE_NOEXCEPT { - return 1693; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailRoleSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailRoleInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailRoleSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailRoleEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailRoleEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD PartyDetailRole::Value - partyDetailRole() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); - return PartyDetailRole::get(SBE_LITTLE_ENDIAN_ENCODE_16(val)); - } - - NoPartyDetails & - partyDetailRole(const PartyDetailRole::Value value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint16_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoPartyDetails writer) { - builder << '{'; - builder << R"("PartyDetailID": )"; - builder << '"' << writer.getPartyDetailIDAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("PartyDetailRole": )"; - builder << '"' << writer.partyDetailRole() << '"'; - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoPartyDetails m_noPartyDetails; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoPartyDetailsId() SBE_NOEXCEPT { - return 1671; - } - - SBE_NODISCARD inline NoPartyDetails &noPartyDetails() { - m_noPartyDetails.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noPartyDetails; - } - - NoPartyDetails &noPartyDetailsCount(const std::uint8_t count) { - m_noPartyDetails.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noPartyDetails; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noPartyDetailsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noPartyDetailsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noPartyDetailsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoTrdRegPublications { + class NoTrdRegPublications + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)2); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 2; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoTrdRegPublications &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *TrdRegPublicationTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - trdRegPublicationTypeId() SBE_NOEXCEPT { - return 2669; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - trdRegPublicationTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool trdRegPublicationTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= trdRegPublicationTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - trdRegPublicationTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t trdRegPublicationType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); - return (val); - } - - NoTrdRegPublications & - trdRegPublicationType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *TrdRegPublicationReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - trdRegPublicationReasonId() SBE_NOEXCEPT { - return 2670; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - trdRegPublicationReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool trdRegPublicationReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= trdRegPublicationReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - trdRegPublicationReasonEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t trdRegPublicationReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint8_t)); - return (val); - } - - NoTrdRegPublications & - trdRegPublicationReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - NoTrdRegPublications writer) { - builder << '{'; - builder << R"("TrdRegPublicationType": )"; - builder << +writer.trdRegPublicationType(); - - builder << ", "; - builder << R"("TrdRegPublicationReason": )"; - builder << +writer.trdRegPublicationReason(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoTrdRegPublications m_noTrdRegPublications; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoTrdRegPublicationsId() SBE_NOEXCEPT { - return 2668; - } - - SBE_NODISCARD inline NoTrdRegPublications &noTrdRegPublications() { - m_noTrdRegPublications.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noTrdRegPublications; - } - - NoTrdRegPublications &noTrdRegPublicationsCount(const std::uint8_t count) { - m_noTrdRegPublications.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noTrdRegPublications; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noTrdRegPublicationsSinceVersion() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD bool noTrdRegPublicationsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noTrdRegPublicationsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - PartyDetailsDefinitionRequest518 _writer) { - PartyDetailsDefinitionRequest518 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "PartyDetailsDefinitionRequest518", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("ListUpdateAction": )"; - builder << '"' << writer.listUpdateAction() << '"'; - - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("Memo": )"; - builder << '"' << writer.getMemoAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("AvgPxGroupID": )"; - builder << '"' << writer.getAvgPxGroupIDAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("SelfMatchPreventionID": )"; - builder << +writer.selfMatchPreventionID(); - - builder << ", "; - builder << R"("CmtaGiveupCD": )"; - builder << '"' << writer.cmtaGiveupCD() << '"'; - - builder << ", "; - builder << R"("CustOrderCapacity": )"; - builder << '"' << writer.custOrderCapacity() << '"'; - - builder << ", "; - builder << R"("ClearingAccountType": )"; - builder << '"' << writer.clearingAccountType() << '"'; - - builder << ", "; - builder << R"("SelfMatchPreventionInstruction": )"; - builder << '"' << writer.selfMatchPreventionInstruction() << '"'; - - builder << ", "; - builder << R"("AvgPxIndicator": )"; - builder << '"' << writer.avgPxIndicator() << '"'; - - builder << ", "; - builder << R"("ClearingTradePriceType": )"; - builder << '"' << writer.clearingTradePriceType() << '"'; - - builder << ", "; - builder << R"("CustOrderHandlingInst": )"; - builder << '"' << writer.custOrderHandlingInst() << '"'; - - builder << ", "; - builder << R"("Executor": )"; - builder << +writer.executor(); - - builder << ", "; - builder << R"("IDMShortCode": )"; - builder << +writer.iDMShortCode(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoPartyDetails": [)"; - writer.noPartyDetails().forEach([&](NoPartyDetails &noPartyDetails) { - if (atLeastOne) { - builder << ", "; + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - atLeastOne = true; - builder << noPartyDetails; - }); - builder << ']'; - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(2)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 2; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoTrdRegPublications": [)"; - writer.noTrdRegPublications().forEach( - [&](NoTrdRegPublications &noTrdRegPublications) { - if (atLeastOne) { - builder << ", "; + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoTrdRegPublications &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *TrdRegPublicationTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t trdRegPublicationTypeId() SBE_NOEXCEPT + { + return 2669; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t trdRegPublicationTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool trdRegPublicationTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= trdRegPublicationTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t trdRegPublicationType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); + return (val); + } + + NoTrdRegPublications &trdRegPublicationType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *TrdRegPublicationReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t trdRegPublicationReasonId() SBE_NOEXCEPT + { + return 2670; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t trdRegPublicationReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool trdRegPublicationReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= trdRegPublicationReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t trdRegPublicationReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint8_t)); + return (val); + } + + NoTrdRegPublications &trdRegPublicationReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoTrdRegPublications writer) + { + builder << '{'; + builder << R"("TrdRegPublicationType": )"; + builder << +writer.trdRegPublicationType(); + + builder << ", "; + builder << R"("TrdRegPublicationReason": )"; + builder << +writer.trdRegPublicationReason(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif + } + }; + +private: + NoTrdRegPublications m_noTrdRegPublications; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoTrdRegPublicationsId() SBE_NOEXCEPT + { + return 2668; + } + + SBE_NODISCARD inline NoTrdRegPublications &noTrdRegPublications() + { + m_noTrdRegPublications.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noTrdRegPublications; + } + + NoTrdRegPublications &noTrdRegPublicationsCount(const std::uint8_t count) + { + m_noTrdRegPublications.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noTrdRegPublications; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noTrdRegPublicationsSinceVersion() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD bool noTrdRegPublicationsInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noTrdRegPublicationsSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, PartyDetailsDefinitionRequest518 _writer) +{ + PartyDetailsDefinitionRequest518 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "PartyDetailsDefinitionRequest518", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("ListUpdateAction": )"; + builder << '"' << writer.listUpdateAction() << '"'; + + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("Memo": )"; + builder << '"' << + writer.getMemoAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("AvgPxGroupID": )"; + builder << '"' << + writer.getAvgPxGroupIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SelfMatchPreventionID": )"; + builder << +writer.selfMatchPreventionID(); + + builder << ", "; + builder << R"("CmtaGiveupCD": )"; + builder << '"' << writer.cmtaGiveupCD() << '"'; + + builder << ", "; + builder << R"("CustOrderCapacity": )"; + builder << '"' << writer.custOrderCapacity() << '"'; + + builder << ", "; + builder << R"("ClearingAccountType": )"; + builder << '"' << writer.clearingAccountType() << '"'; + + builder << ", "; + builder << R"("SelfMatchPreventionInstruction": )"; + builder << '"' << writer.selfMatchPreventionInstruction() << '"'; + + builder << ", "; + builder << R"("AvgPxIndicator": )"; + builder << '"' << writer.avgPxIndicator() << '"'; + + builder << ", "; + builder << R"("ClearingTradePriceType": )"; + builder << '"' << writer.clearingTradePriceType() << '"'; + + builder << ", "; + builder << R"("CustOrderHandlingInst": )"; + builder << '"' << writer.custOrderHandlingInst() << '"'; + + builder << ", "; + builder << R"("Executor": )"; + builder << +writer.executor(); + + builder << ", "; + builder << R"("IDMShortCode": )"; + builder << +writer.iDMShortCode(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoPartyDetails": [)"; + writer.noPartyDetails().forEach( + [&](NoPartyDetails &noPartyDetails) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noPartyDetails; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoTrdRegPublications": [)"; + writer.noTrdRegPublications().forEach( + [&](NoTrdRegPublications &noTrdRegPublications) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noTrdRegPublications; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} - void skip() { - noPartyDetails().forEach([](NoPartyDetails e) { e.skip(); }); - noTrdRegPublications().forEach([](NoTrdRegPublications e) { e.skip(); }); - } +void skip() +{ + auto &noPartyDetailsGroup { noPartyDetails() }; + while (noPartyDetailsGroup.hasNext()) + { + noPartyDetailsGroup.next().skip(); + } + auto &noTrdRegPublicationsGroup { noTrdRegPublications() }; + while (noTrdRegPublicationsGroup.hasNext()) + { + noTrdRegPublicationsGroup.next().skip(); + } +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoPartyDetailsLength = 0, - std::size_t NoTrdRegPublicationsLength = 0) { +SBE_NODISCARD static std::size_t computeLength( + std::size_t noPartyDetailsLength = 0, + std::size_t noTrdRegPublicationsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoPartyDetails::sbeHeaderSize(); - if (NoPartyDetailsLength > 254) { - throw std::runtime_error( - "NoPartyDetailsLength outside of allowed range [E110]"); - } - length += NoPartyDetailsLength * NoPartyDetails::sbeBlockLength(); + length += NoPartyDetails::sbeHeaderSize(); + if (noPartyDetailsLength > 254LL) + { + throw std::runtime_error("noPartyDetailsLength outside of allowed range [E110]"); + } + length += noPartyDetailsLength *NoPartyDetails::sbeBlockLength(); - length += NoTrdRegPublications::sbeHeaderSize(); - if (NoTrdRegPublicationsLength > 254) { - throw std::runtime_error( - "NoTrdRegPublicationsLength outside of allowed range [E110]"); - } - length += - NoTrdRegPublicationsLength * NoTrdRegPublications::sbeBlockLength(); - return length; + length += NoTrdRegPublications::sbeHeaderSize(); + if (noTrdRegPublicationsLength > 254LL) + { + throw std::runtime_error("noTrdRegPublicationsLength outside of allowed range [E110]"); + } + length += noTrdRegPublicationsLength *NoTrdRegPublications::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/PartyDetailsDefinitionRequestAck519.h b/src/lib/orderman/ilink3/generated/PartyDetailsDefinitionRequestAck519.h index 5b0ef0729..04ce72a30 100644 --- a/src/lib/orderman/ilink3/generated/PartyDetailsDefinitionRequestAck519.h +++ b/src/lib/orderman/ilink3/generated/PartyDetailsDefinitionRequestAck519.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2960 +86,3180 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class PartyDetailsDefinitionRequestAck519 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class PartyDetailsDefinitionRequestAck519 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(159); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(519); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - PartyDetailsDefinitionRequestAck519() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - PartyDetailsDefinitionRequestAck519( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - PartyDetailsDefinitionRequestAck519( - char *buffer, const std::uint64_t bufferLength) - : PartyDetailsDefinitionRequestAck519( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + PartyDetailsDefinitionRequestAck519() = default; - PartyDetailsDefinitionRequestAck519( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : PartyDetailsDefinitionRequestAck519( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + PartyDetailsDefinitionRequestAck519( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)159; - } + PartyDetailsDefinitionRequestAck519(char *buffer, const std::uint64_t bufferLength) : + PartyDetailsDefinitionRequestAck519(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + PartyDetailsDefinitionRequestAck519( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + PartyDetailsDefinitionRequestAck519(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)519; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(159); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(519); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "CY"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - PartyDetailsDefinitionRequestAck519 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = PartyDetailsDefinitionRequestAck519( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "CY"; + } - PartyDetailsDefinitionRequestAck519 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + PartyDetailsDefinitionRequestAck519 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = PartyDetailsDefinitionRequestAck519(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = PartyDetailsDefinitionRequestAck519( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + PartyDetailsDefinitionRequestAck519 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - PartyDetailsDefinitionRequestAck519 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = PartyDetailsDefinitionRequestAck519( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = PartyDetailsDefinitionRequestAck519( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + PartyDetailsDefinitionRequestAck519 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = PartyDetailsDefinitionRequestAck519(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + PartyDetailsDefinitionRequestAck519 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - PartyDetailsDefinitionRequestAck519 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + PartyDetailsDefinitionRequestAck519 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - PartyDetailsDefinitionRequestAck519 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + PartyDetailsDefinitionRequestAck519 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequestAck519 & - uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequestAck519 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - MemoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MemoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t memoId() SBE_NOEXCEPT { return 5149; } + static SBE_CONSTEXPR std::uint16_t memoId() SBE_NOEXCEPT + { + return 5149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - memoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t memoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool memoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool memoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= memoSinceVersion(); + return m_actingVersion >= memoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - memoEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t memoEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char memoNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char memoNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char memoMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char memoMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char memoMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char memoMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t memoEncodingLength() SBE_NOEXCEPT { - return 75; - } + static SBE_CONSTEXPR std::size_t memoEncodingLength() SBE_NOEXCEPT + { + return 75; + } - static SBE_CONSTEXPR std::uint64_t memoLength() SBE_NOEXCEPT { return 75; } + static SBE_CONSTEXPR std::uint64_t memoLength() SBE_NOEXCEPT + { + return 75; + } - SBE_NODISCARD const char *memo() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *memo() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *memo() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } + SBE_NODISCARD char *memo() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char memo(const std::uint64_t index) const { - if (index >= 75) { - throw std::runtime_error("index out of range for memo [E104]"); - } + SBE_NODISCARD char memo(const std::uint64_t index) const + { + if (index >= 75) + { + throw std::runtime_error("index out of range for memo [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - memo(const std::uint64_t index, const char value) { - if (index >= 75) { - throw std::runtime_error("index out of range for memo [E105]"); - } + PartyDetailsDefinitionRequestAck519 &memo(const std::uint64_t index, const char value) + { + if (index >= 75) + { + throw std::runtime_error("index out of range for memo [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getMemo(char *const dst, const std::uint64_t length) const { - if (length > 75) { - throw std::runtime_error("length too large for getMemo [E106]"); - } + std::uint64_t getMemo(char *const dst, const std::uint64_t length) const + { + if (length > 75) + { + throw std::runtime_error("length too large for getMemo [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - PartyDetailsDefinitionRequestAck519 & - putMemo(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 75); - return *this; - } + PartyDetailsDefinitionRequestAck519 &putMemo(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 75); + return *this; + } - SBE_NODISCARD std::string getMemoAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getMemoAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 75 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 75 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getMemoAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMemoAsString(); + std::string getMemoAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMemoAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getMemoAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getMemoAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 75 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 75 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - PartyDetailsDefinitionRequestAck519 &putMemo(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 75) { - throw std::runtime_error("string too large for putMemo [E106]"); - } + #if __cplusplus >= 201703L + PartyDetailsDefinitionRequestAck519 &putMemo(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 75) + { + throw std::runtime_error("string too large for putMemo [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 75; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 75; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - PartyDetailsDefinitionRequestAck519 &putMemo(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 75) { - throw std::runtime_error("string too large for putMemo [E106]"); - } + return *this; + } + #else + PartyDetailsDefinitionRequestAck519 &putMemo(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 75) + { + throw std::runtime_error("string too large for putMemo [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 75; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 75; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t avgPxGroupIDId() SBE_NOEXCEPT { - return 1731; - } + static SBE_CONSTEXPR std::uint16_t avgPxGroupIDId() SBE_NOEXCEPT + { + return 1731; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - avgPxGroupIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t avgPxGroupIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool avgPxGroupIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool avgPxGroupIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= avgPxGroupIDSinceVersion(); + return m_actingVersion >= avgPxGroupIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - avgPxGroupIDEncodingOffset() SBE_NOEXCEPT { - return 87; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingOffset() SBE_NOEXCEPT + { + return 87; + } - static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t avgPxGroupIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t avgPxGroupIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *avgPxGroupID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 87; - } + SBE_NODISCARD const char *avgPxGroupID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 87; + } - SBE_NODISCARD char *avgPxGroupID() SBE_NOEXCEPT { - return m_buffer + m_offset + 87; - } + SBE_NODISCARD char *avgPxGroupID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 87; + } - SBE_NODISCARD char avgPxGroupID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for avgPxGroupID [E104]"); - } + SBE_NODISCARD char avgPxGroupID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for avgPxGroupID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 87 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 87 + (index * 1), sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - avgPxGroupID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for avgPxGroupID [E105]"); - } + PartyDetailsDefinitionRequestAck519 &avgPxGroupID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for avgPxGroupID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 87 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 87 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getAvgPxGroupID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getAvgPxGroupID [E106]"); - } + std::uint64_t getAvgPxGroupID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getAvgPxGroupID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 87, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 87, sizeof(char) * static_cast(length)); + return length; + } - PartyDetailsDefinitionRequestAck519 & - putAvgPxGroupID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 87, src, sizeof(char) * 20); - return *this; - } + PartyDetailsDefinitionRequestAck519 &putAvgPxGroupID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 87, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getAvgPxGroupIDAsString() const { - const char *buffer = m_buffer + m_offset + 87; - size_t length = 0; + SBE_NODISCARD std::string getAvgPxGroupIDAsString() const + { + const char *buffer = m_buffer + m_offset + 87; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getAvgPxGroupIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAvgPxGroupIDAsString(); + std::string getAvgPxGroupIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAvgPxGroupIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 87; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 87; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - PartyDetailsDefinitionRequestAck519 & - putAvgPxGroupID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putAvgPxGroupID [E106]"); - } + #if __cplusplus >= 201703L + PartyDetailsDefinitionRequestAck519 &putAvgPxGroupID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); + } - std::memcpy(m_buffer + m_offset + 87, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 87 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 87, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 87 + start] = 0; + } - return *this; - } -#else - PartyDetailsDefinitionRequestAck519 & - putAvgPxGroupID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putAvgPxGroupID [E106]"); - } + return *this; + } + #else + PartyDetailsDefinitionRequestAck519 &putAvgPxGroupID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); + } - std::memcpy(m_buffer + m_offset + 87, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 87 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 87, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 87 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 107; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 107; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequestAck519 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequestAck519 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 115; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 115; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 115, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 115, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequestAck519 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 115, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequestAck519 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 115, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SelfMatchPreventionIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SelfMatchPreventionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t selfMatchPreventionIDId() SBE_NOEXCEPT { - return 2362; - } + static SBE_CONSTEXPR std::uint16_t selfMatchPreventionIDId() SBE_NOEXCEPT + { + return 2362; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool selfMatchPreventionIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool selfMatchPreventionIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= selfMatchPreventionIDSinceVersion(); + return m_actingVersion >= selfMatchPreventionIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - selfMatchPreventionIDEncodingOffset() SBE_NOEXCEPT { - return 123; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingOffset() SBE_NOEXCEPT + { + return 123; + } - static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t selfMatchPreventionID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 123, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t selfMatchPreventionID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 123, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequestAck519 & - selfMatchPreventionID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 123, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequestAck519 &selfMatchPreventionID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 123, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *PartyDetailRequestStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailRequestStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t - partyDetailRequestStatusId() SBE_NOEXCEPT { - return 1878; - } + static SBE_CONSTEXPR std::uint16_t partyDetailRequestStatusId() SBE_NOEXCEPT + { + return 1878; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailRequestStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailRequestStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailRequestStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailRequestStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailRequestStatusSinceVersion(); + return m_actingVersion >= partyDetailRequestStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailRequestStatusEncodingOffset() SBE_NOEXCEPT { - return 131; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailRequestStatusEncodingOffset() SBE_NOEXCEPT + { + return 131; + } - static SBE_CONSTEXPR std::uint8_t - partyDetailRequestStatusNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t partyDetailRequestStatusNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t - partyDetailRequestStatusMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t partyDetailRequestStatusMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t - partyDetailRequestStatusMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t partyDetailRequestStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - partyDetailRequestStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t partyDetailRequestStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t partyDetailRequestStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 131, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t partyDetailRequestStatus() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 131, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - partyDetailRequestStatus(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 131, &val, sizeof(std::uint8_t)); - return *this; - } + PartyDetailsDefinitionRequestAck519 &partyDetailRequestStatus(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 131, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *CustOrderCapacityMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CustOrderCapacityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t custOrderCapacityId() SBE_NOEXCEPT { - return 582; - } + static SBE_CONSTEXPR std::uint16_t custOrderCapacityId() SBE_NOEXCEPT + { + return 582; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - custOrderCapacitySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t custOrderCapacitySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool custOrderCapacityInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool custOrderCapacityInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= custOrderCapacitySinceVersion(); + return m_actingVersion >= custOrderCapacitySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderCapacityEncodingOffset() SBE_NOEXCEPT { - return 132; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderCapacityEncodingOffset() SBE_NOEXCEPT + { + return 132; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderCapacityEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderCapacityEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD CustOrderCapacity::Value - custOrderCapacity() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint8_t)); - return CustOrderCapacity::get((val)); - } + SBE_NODISCARD std::uint8_t custOrderCapacityRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - custOrderCapacity(const CustOrderCapacity::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD CustOrderCapacity::Value custOrderCapacity() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 132, sizeof(std::uint8_t)); + return CustOrderCapacity::get((val)); + } - SBE_NODISCARD static const char *ClearingAccountTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequestAck519 &custOrderCapacity(const CustOrderCapacity::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 132, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t clearingAccountTypeId() SBE_NOEXCEPT { - return 1816; - } + SBE_NODISCARD static const char *ClearingAccountTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearingAccountTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t clearingAccountTypeId() SBE_NOEXCEPT + { + return 1816; + } - SBE_NODISCARD bool clearingAccountTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearingAccountTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clearingAccountTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearingAccountTypeSinceVersion(); + return m_actingVersion >= clearingAccountTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingAccountTypeEncodingOffset() SBE_NOEXCEPT { - return 133; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingAccountTypeEncodingOffset() SBE_NOEXCEPT + { + return 133; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingAccountTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingAccountTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ClearingAcctType::Value - clearingAccountType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 133, sizeof(std::uint8_t)); - return ClearingAcctType::get((val)); - } + SBE_NODISCARD std::uint8_t clearingAccountTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 133, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - clearingAccountType(const ClearingAcctType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 133, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ClearingAcctType::Value clearingAccountType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 133, sizeof(std::uint8_t)); + return ClearingAcctType::get((val)); + } - SBE_NODISCARD static const char *SelfMatchPreventionInstructionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequestAck519 &clearingAccountType(const ClearingAcctType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 133, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t - selfMatchPreventionInstructionId() SBE_NOEXCEPT { - return 8000; - } + SBE_NODISCARD static const char *SelfMatchPreventionInstructionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionInstructionSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t selfMatchPreventionInstructionId() SBE_NOEXCEPT + { + return 8000; + } - SBE_NODISCARD bool - selfMatchPreventionInstructionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t selfMatchPreventionInstructionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool selfMatchPreventionInstructionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= selfMatchPreventionInstructionSinceVersion(); + return m_actingVersion >= selfMatchPreventionInstructionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - selfMatchPreventionInstructionEncodingOffset() SBE_NOEXCEPT { - return 134; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t selfMatchPreventionInstructionEncodingOffset() SBE_NOEXCEPT + { + return 134; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - selfMatchPreventionInstructionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t selfMatchPreventionInstructionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SMPI::Value - selfMatchPreventionInstruction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 134, sizeof(char)); - return SMPI::get((val)); - } + SBE_NODISCARD char selfMatchPreventionInstructionRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 134, sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - selfMatchPreventionInstruction(const SMPI::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 134, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD SMPI::Value selfMatchPreventionInstruction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 134, sizeof(char)); + return SMPI::get((val)); + } - SBE_NODISCARD static const char * - AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequestAck519 &selfMatchPreventionInstruction(const SMPI::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 134, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t avgPxIndicatorId() SBE_NOEXCEPT { - return 819; - } + SBE_NODISCARD static const char *AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - avgPxIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t avgPxIndicatorId() SBE_NOEXCEPT + { + return 819; + } - SBE_NODISCARD bool avgPxIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t avgPxIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool avgPxIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= avgPxIndicatorSinceVersion(); + return m_actingVersion >= avgPxIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - avgPxIndicatorEncodingOffset() SBE_NOEXCEPT { - return 135; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t avgPxIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 135; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - avgPxIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t avgPxIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 135, sizeof(std::uint8_t)); - return AvgPxInd::get((val)); - } + SBE_NODISCARD std::uint8_t avgPxIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 135, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - avgPxIndicator(const AvgPxInd::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 135, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 135, sizeof(std::uint8_t)); + return AvgPxInd::get((val)); + } - SBE_NODISCARD static const char *ClearingTradePriceTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequestAck519 &avgPxIndicator(const AvgPxInd::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 135, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t clearingTradePriceTypeId() SBE_NOEXCEPT { - return 1598; - } + SBE_NODISCARD static const char *ClearingTradePriceTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearingTradePriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t clearingTradePriceTypeId() SBE_NOEXCEPT + { + return 1598; + } - SBE_NODISCARD bool clearingTradePriceTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearingTradePriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clearingTradePriceTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearingTradePriceTypeSinceVersion(); + return m_actingVersion >= clearingTradePriceTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingTradePriceTypeEncodingOffset() SBE_NOEXCEPT { - return 136; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingTradePriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 136; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingTradePriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingTradePriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SLEDS::Value clearingTradePriceType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 136, sizeof(std::uint8_t)); - return SLEDS::get((val)); - } + SBE_NODISCARD std::uint8_t clearingTradePriceTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 136, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - clearingTradePriceType(const SLEDS::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 136, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SLEDS::Value clearingTradePriceType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 136, sizeof(std::uint8_t)); + return SLEDS::get((val)); + } - SBE_NODISCARD static const char * - CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequestAck519 &clearingTradePriceType(const SLEDS::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 136, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t cmtaGiveupCDId() SBE_NOEXCEPT { - return 9708; - } + SBE_NODISCARD static const char *CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cmtaGiveupCDSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t cmtaGiveupCDId() SBE_NOEXCEPT + { + return 9708; + } - SBE_NODISCARD bool cmtaGiveupCDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cmtaGiveupCDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool cmtaGiveupCDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cmtaGiveupCDSinceVersion(); + return m_actingVersion >= cmtaGiveupCDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cmtaGiveupCDEncodingOffset() SBE_NOEXCEPT { - return 137; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cmtaGiveupCDEncodingOffset() SBE_NOEXCEPT + { + return 137; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cmtaGiveupCDEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cmtaGiveupCDEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 137, sizeof(char)); - return CmtaGiveUpCD::get((val)); - } + SBE_NODISCARD char cmtaGiveupCDRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 137, sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - cmtaGiveupCD(const CmtaGiveUpCD::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 137, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 137, sizeof(char)); + return CmtaGiveUpCD::get((val)); + } - SBE_NODISCARD static const char *CustOrderHandlingInstMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequestAck519 &cmtaGiveupCD(const CmtaGiveUpCD::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 137, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t custOrderHandlingInstId() SBE_NOEXCEPT { - return 1031; - } + SBE_NODISCARD static const char *CustOrderHandlingInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - custOrderHandlingInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t custOrderHandlingInstId() SBE_NOEXCEPT + { + return 1031; + } - SBE_NODISCARD bool custOrderHandlingInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t custOrderHandlingInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool custOrderHandlingInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= custOrderHandlingInstSinceVersion(); + return m_actingVersion >= custOrderHandlingInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderHandlingInstEncodingOffset() SBE_NOEXCEPT { - return 138; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderHandlingInstEncodingOffset() SBE_NOEXCEPT + { + return 138; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderHandlingInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderHandlingInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD CustOrdHandlInst::Value - custOrderHandlingInst() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 138, sizeof(char)); - return CustOrdHandlInst::get((val)); - } + SBE_NODISCARD char custOrderHandlingInstRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 138, sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - custOrderHandlingInst(const CustOrdHandlInst::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 138, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD CustOrdHandlInst::Value custOrderHandlingInst() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 138, sizeof(char)); + return CustOrdHandlInst::get((val)); + } - SBE_NODISCARD static const char * - NoPartyUpdatesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + PartyDetailsDefinitionRequestAck519 &custOrderHandlingInst(const CustOrdHandlInst::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 138, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t noPartyUpdatesId() SBE_NOEXCEPT { - return 1676; - } + SBE_NODISCARD static const char *NoPartyUpdatesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noPartyUpdatesSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t noPartyUpdatesId() SBE_NOEXCEPT + { + return 1676; + } - SBE_NODISCARD bool noPartyUpdatesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noPartyUpdatesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noPartyUpdatesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noPartyUpdatesSinceVersion(); + return m_actingVersion >= noPartyUpdatesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - noPartyUpdatesEncodingOffset() SBE_NOEXCEPT { - return 139; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t noPartyUpdatesEncodingOffset() SBE_NOEXCEPT + { + return 139; + } - static SBE_CONSTEXPR std::uint8_t noPartyUpdatesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t noPartyUpdatesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t noPartyUpdatesMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - noPartyUpdatesEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t noPartyUpdatesEncodingLength() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint8_t - noPartyUpdates() SBE_NOEXCEPT { - return (std::uint8_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint8_t noPartyUpdates() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static const char *ListUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ListUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t listUpdateActionId() SBE_NOEXCEPT { - return 1324; - } + static SBE_CONSTEXPR std::uint16_t listUpdateActionId() SBE_NOEXCEPT + { + return 1324; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - listUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t listUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool listUpdateActionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool listUpdateActionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= listUpdateActionSinceVersion(); + return m_actingVersion >= listUpdateActionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - listUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 139; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t listUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 139; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - listUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t listUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ListUpdAct::Value listUpdateAction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 139, sizeof(char)); - return ListUpdAct::get((val)); - } + SBE_NODISCARD char listUpdateActionRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 139, sizeof(char)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - listUpdateAction(const ListUpdAct::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 139, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD ListUpdAct::Value listUpdateAction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 139, sizeof(char)); + return ListUpdAct::get((val)); + } - SBE_NODISCARD static const char *PartyDetailDefinitionStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequestAck519 &listUpdateAction(const ListUpdAct::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 139, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t - partyDetailDefinitionStatusId() SBE_NOEXCEPT { - return 1879; - } + SBE_NODISCARD static const char *PartyDetailDefinitionStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailDefinitionStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t partyDetailDefinitionStatusId() SBE_NOEXCEPT + { + return 1879; + } - SBE_NODISCARD bool - partyDetailDefinitionStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailDefinitionStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailDefinitionStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailDefinitionStatusSinceVersion(); + return m_actingVersion >= partyDetailDefinitionStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailDefinitionStatusEncodingOffset() SBE_NOEXCEPT { - return 140; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailDefinitionStatusEncodingOffset() SBE_NOEXCEPT + { + return 140; + } - static SBE_CONSTEXPR std::uint8_t - partyDetailDefinitionStatusNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t partyDetailDefinitionStatusNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t - partyDetailDefinitionStatusMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t partyDetailDefinitionStatusMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t - partyDetailDefinitionStatusMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t partyDetailDefinitionStatusMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - partyDetailDefinitionStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t partyDetailDefinitionStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t partyDetailDefinitionStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t partyDetailDefinitionStatus() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 140, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - partyDetailDefinitionStatus(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint8_t)); - return *this; - } + PartyDetailsDefinitionRequestAck519 &partyDetailDefinitionStatus(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 140, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t executorId() SBE_NOEXCEPT { return 5290; } + static SBE_CONSTEXPR std::uint16_t executorId() SBE_NOEXCEPT + { + return 5290; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool executorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool executorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executorSinceVersion(); + return m_actingVersion >= executorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executorEncodingOffset() SBE_NOEXCEPT { - return 141; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executorEncodingOffset() SBE_NOEXCEPT + { + return 141; + } - static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t executor() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 141, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t executor() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 141, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequestAck519 & - executor(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 141, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequestAck519 &executor(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 141, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t iDMShortCodeId() SBE_NOEXCEPT { - return 36023; - } + static SBE_CONSTEXPR std::uint16_t iDMShortCodeId() SBE_NOEXCEPT + { + return 36023; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - iDMShortCodeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t iDMShortCodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool iDMShortCodeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool iDMShortCodeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= iDMShortCodeSinceVersion(); + return m_actingVersion >= iDMShortCodeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - iDMShortCodeEncodingOffset() SBE_NOEXCEPT { - return 149; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingOffset() SBE_NOEXCEPT + { + return 149; + } - static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t iDMShortCode() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 149, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t iDMShortCode() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 149, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsDefinitionRequestAck519 & - iDMShortCode(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 149, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsDefinitionRequestAck519 &iDMShortCode(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 149, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 157; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 157; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsDefinitionRequestAck519 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 158; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 158; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 158, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 158, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsDefinitionRequestAck519 & - splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 158, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 158, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - class NoPartyDetails { + PartyDetailsDefinitionRequestAck519 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 158, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoPartyDetails + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(22)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 22; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 22; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoPartyDetails &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *PartyDetailIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailIDId() SBE_NOEXCEPT + { + return 1691; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t partyDetailIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *partyDetailID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char *partyDetailID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char partyDetailID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for partyDetailID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } + + NoPartyDetails &partyDetailID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for partyDetailID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getPartyDetailID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getPartyDetailID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoPartyDetails &putPartyDetailID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getPartyDetailIDAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getPartyDetailIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getPartyDetailIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getPartyDetailIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoPartyDetails &putPartyDetailID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putPartyDetailID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoPartyDetails &putPartyDetailID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putPartyDetailID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailIDSourceId() SBE_NOEXCEPT + { + return 1692; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailIDSourceLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *partyDetailIDSource() const + { + static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 }; + + return (const char *)partyDetailIDSourceValues; + } + + SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const + { + static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 }; + + return (char)partyDetailIDSourceValues[index]; + } + + std::uint64_t getPartyDetailIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t partyDetailIDSourceValues[] = { 67 }; + std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) ? length : sizeof(partyDetailIDSourceValues); + + std::memcpy(dst, partyDetailIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getPartyDetailIDSourceAsString() const + { + static const std::uint8_t PartyDetailIDSourceValues[] = { 67 }; + + return std::string((const char *)PartyDetailIDSourceValues, 1); + } + + std::string getPartyDetailIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getPartyDetailIDSourceAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *PartyDetailRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailRoleId() SBE_NOEXCEPT + { + return 1693; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailRoleSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailRoleInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailRoleSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailRoleEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailRoleEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t partyDetailRoleRaw() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + SBE_NODISCARD PartyDetailRole::Value partyDetailRole() const + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); + return PartyDetailRole::get(SBE_LITTLE_ENDIAN_ENCODE_16(val)); + } + + NoPartyDetails &partyDetailRole(const PartyDetailRole::Value value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint16_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoPartyDetails writer) + { + builder << '{'; + builder << R"("PartyDetailID": )"; + builder << '"' << + writer.getPartyDetailIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailRole": )"; + builder << '"' << writer.partyDetailRole() << '"'; + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)22); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 22; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoPartyDetails m_noPartyDetails; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 22; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoPartyDetailsId() SBE_NOEXCEPT + { + return 1671; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoPartyDetails &noPartyDetails() + { + m_noPartyDetails.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noPartyDetails; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoPartyDetails &noPartyDetailsCount(const std::uint8_t count) + { + m_noPartyDetails.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noPartyDetails; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noPartyDetailsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoPartyDetails &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *PartyDetailIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailIDId() SBE_NOEXCEPT { - return 1691; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noPartyDetailsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailIDSinceVersion(); + return m_actingVersion >= noPartyDetailsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - partyDetailIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t partyDetailIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *partyDetailID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *partyDetailID() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char partyDetailID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error( - "index out of range for partyDetailID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoPartyDetails & - partyDetailID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error( - "index out of range for partyDetailID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getPartyDetailID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getPartyDetailID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoPartyDetails &putPartyDetailID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getPartyDetailIDAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getPartyDetailIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getPartyDetailIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getPartyDetailIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoPartyDetails &putPartyDetailID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putPartyDetailID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoPartyDetails &putPartyDetailID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putPartyDetailID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailIDSourceMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailIDSourceId() SBE_NOEXCEPT { - return 1692; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailIDSourceEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - partyDetailIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailIDSourceLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *partyDetailIDSource() const { - static const std::uint8_t partyDetailIDSourceValues[] = {67}; - - return (const char *)partyDetailIDSourceValues; - } - - SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const { - static const std::uint8_t partyDetailIDSourceValues[] = {67}; - - return (char)partyDetailIDSourceValues[index]; - } - - std::uint64_t - getPartyDetailIDSource(char *dst, const std::uint64_t length) const { - static std::uint8_t partyDetailIDSourceValues[] = {67}; - std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) - ? length - : sizeof(partyDetailIDSourceValues); - - std::memcpy( - dst, partyDetailIDSourceValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getPartyDetailIDSourceAsString() const { - static const std::uint8_t PartyDetailIDSourceValues[] = {67}; - - return std::string((const char *)PartyDetailIDSourceValues, 1); - } - - std::string getPartyDetailIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getPartyDetailIDSourceAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char *PartyDetailRoleMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailRoleId() SBE_NOEXCEPT { - return 1693; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailRoleSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailRoleInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailRoleSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailRoleEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailRoleEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD PartyDetailRole::Value - partyDetailRole() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); - return PartyDetailRole::get(SBE_LITTLE_ENDIAN_ENCODE_16(val)); - } - - NoPartyDetails & - partyDetailRole(const PartyDetailRole::Value value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint16_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoPartyDetails writer) { - builder << '{'; - builder << R"("PartyDetailID": )"; - builder << '"' << writer.getPartyDetailIDAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("PartyDetailRole": )"; - builder << '"' << writer.partyDetailRole() << '"'; - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoPartyDetails m_noPartyDetails; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoPartyDetailsId() SBE_NOEXCEPT { - return 1671; - } - - SBE_NODISCARD inline NoPartyDetails &noPartyDetails() { - m_noPartyDetails.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noPartyDetails; - } - - NoPartyDetails &noPartyDetailsCount(const std::uint8_t count) { - m_noPartyDetails.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noPartyDetails; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noPartyDetailsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noPartyDetailsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noPartyDetailsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoTrdRegPublications { + class NoTrdRegPublications + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)2); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 2; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoTrdRegPublications &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *TrdRegPublicationTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - trdRegPublicationTypeId() SBE_NOEXCEPT { - return 2669; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - trdRegPublicationTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool trdRegPublicationTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= trdRegPublicationTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - trdRegPublicationTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t trdRegPublicationType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); - return (val); - } - - NoTrdRegPublications & - trdRegPublicationType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *TrdRegPublicationReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - trdRegPublicationReasonId() SBE_NOEXCEPT { - return 2670; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - trdRegPublicationReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool trdRegPublicationReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= trdRegPublicationReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - trdRegPublicationReasonEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t trdRegPublicationReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint8_t)); - return (val); - } - - NoTrdRegPublications & - trdRegPublicationReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - NoTrdRegPublications writer) { - builder << '{'; - builder << R"("TrdRegPublicationType": )"; - builder << +writer.trdRegPublicationType(); - - builder << ", "; - builder << R"("TrdRegPublicationReason": )"; - builder << +writer.trdRegPublicationReason(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoTrdRegPublications m_noTrdRegPublications; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoTrdRegPublicationsId() SBE_NOEXCEPT { - return 2668; - } - - SBE_NODISCARD inline NoTrdRegPublications &noTrdRegPublications() { - m_noTrdRegPublications.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noTrdRegPublications; - } - - NoTrdRegPublications &noTrdRegPublicationsCount(const std::uint8_t count) { - m_noTrdRegPublications.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noTrdRegPublications; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noTrdRegPublicationsSinceVersion() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD bool noTrdRegPublicationsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noTrdRegPublicationsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - PartyDetailsDefinitionRequestAck519 _writer) { - PartyDetailsDefinitionRequestAck519 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "PartyDetailsDefinitionRequestAck519", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); - - builder << ", "; - builder << R"("Memo": )"; - builder << '"' << writer.getMemoAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("AvgPxGroupID": )"; - builder << '"' << writer.getAvgPxGroupIDAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("SelfMatchPreventionID": )"; - builder << +writer.selfMatchPreventionID(); - - builder << ", "; - builder << R"("PartyDetailRequestStatus": )"; - builder << +writer.partyDetailRequestStatus(); - - builder << ", "; - builder << R"("CustOrderCapacity": )"; - builder << '"' << writer.custOrderCapacity() << '"'; - - builder << ", "; - builder << R"("ClearingAccountType": )"; - builder << '"' << writer.clearingAccountType() << '"'; - - builder << ", "; - builder << R"("SelfMatchPreventionInstruction": )"; - builder << '"' << writer.selfMatchPreventionInstruction() << '"'; - - builder << ", "; - builder << R"("AvgPxIndicator": )"; - builder << '"' << writer.avgPxIndicator() << '"'; - - builder << ", "; - builder << R"("ClearingTradePriceType": )"; - builder << '"' << writer.clearingTradePriceType() << '"'; - - builder << ", "; - builder << R"("CmtaGiveupCD": )"; - builder << '"' << writer.cmtaGiveupCD() << '"'; - - builder << ", "; - builder << R"("CustOrderHandlingInst": )"; - builder << '"' << writer.custOrderHandlingInst() << '"'; - - builder << ", "; - builder << R"("ListUpdateAction": )"; - builder << '"' << writer.listUpdateAction() << '"'; - - builder << ", "; - builder << R"("PartyDetailDefinitionStatus": )"; - builder << +writer.partyDetailDefinitionStatus(); - - builder << ", "; - builder << R"("Executor": )"; - builder << +writer.executor(); - - builder << ", "; - builder << R"("IDMShortCode": )"; - builder << +writer.iDMShortCode(); - - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; - - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoPartyDetails": [)"; - writer.noPartyDetails().forEach([&](NoPartyDetails &noPartyDetails) { - if (atLeastOne) { - builder << ", "; + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - atLeastOne = true; - builder << noPartyDetails; - }); - builder << ']'; - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(2)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 2; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoTrdRegPublications": [)"; - writer.noTrdRegPublications().forEach( - [&](NoTrdRegPublications &noTrdRegPublications) { - if (atLeastOne) { - builder << ", "; + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoTrdRegPublications &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *TrdRegPublicationTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t trdRegPublicationTypeId() SBE_NOEXCEPT + { + return 2669; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t trdRegPublicationTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool trdRegPublicationTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= trdRegPublicationTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t trdRegPublicationType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); + return (val); + } + + NoTrdRegPublications &trdRegPublicationType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *TrdRegPublicationReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t trdRegPublicationReasonId() SBE_NOEXCEPT + { + return 2670; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t trdRegPublicationReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool trdRegPublicationReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= trdRegPublicationReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t trdRegPublicationReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint8_t)); + return (val); + } + + NoTrdRegPublications &trdRegPublicationReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoTrdRegPublications writer) + { + builder << '{'; + builder << R"("TrdRegPublicationType": )"; + builder << +writer.trdRegPublicationType(); + + builder << ", "; + builder << R"("TrdRegPublicationReason": )"; + builder << +writer.trdRegPublicationReason(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif + } + }; + +private: + NoTrdRegPublications m_noTrdRegPublications; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoTrdRegPublicationsId() SBE_NOEXCEPT + { + return 2668; + } + + SBE_NODISCARD inline NoTrdRegPublications &noTrdRegPublications() + { + m_noTrdRegPublications.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noTrdRegPublications; + } + + NoTrdRegPublications &noTrdRegPublicationsCount(const std::uint8_t count) + { + m_noTrdRegPublications.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noTrdRegPublications; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noTrdRegPublicationsSinceVersion() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD bool noTrdRegPublicationsInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noTrdRegPublicationsSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, PartyDetailsDefinitionRequestAck519 _writer) +{ + PartyDetailsDefinitionRequestAck519 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "PartyDetailsDefinitionRequestAck519", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("Memo": )"; + builder << '"' << + writer.getMemoAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("AvgPxGroupID": )"; + builder << '"' << + writer.getAvgPxGroupIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("SelfMatchPreventionID": )"; + builder << +writer.selfMatchPreventionID(); + + builder << ", "; + builder << R"("PartyDetailRequestStatus": )"; + builder << +writer.partyDetailRequestStatus(); + + builder << ", "; + builder << R"("CustOrderCapacity": )"; + builder << '"' << writer.custOrderCapacity() << '"'; + + builder << ", "; + builder << R"("ClearingAccountType": )"; + builder << '"' << writer.clearingAccountType() << '"'; + + builder << ", "; + builder << R"("SelfMatchPreventionInstruction": )"; + builder << '"' << writer.selfMatchPreventionInstruction() << '"'; + + builder << ", "; + builder << R"("AvgPxIndicator": )"; + builder << '"' << writer.avgPxIndicator() << '"'; + + builder << ", "; + builder << R"("ClearingTradePriceType": )"; + builder << '"' << writer.clearingTradePriceType() << '"'; + + builder << ", "; + builder << R"("CmtaGiveupCD": )"; + builder << '"' << writer.cmtaGiveupCD() << '"'; + + builder << ", "; + builder << R"("CustOrderHandlingInst": )"; + builder << '"' << writer.custOrderHandlingInst() << '"'; + + builder << ", "; + builder << R"("ListUpdateAction": )"; + builder << '"' << writer.listUpdateAction() << '"'; + + builder << ", "; + builder << R"("PartyDetailDefinitionStatus": )"; + builder << +writer.partyDetailDefinitionStatus(); + + builder << ", "; + builder << R"("Executor": )"; + builder << +writer.executor(); + + builder << ", "; + builder << R"("IDMShortCode": )"; + builder << +writer.iDMShortCode(); + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoPartyDetails": [)"; + writer.noPartyDetails().forEach( + [&](NoPartyDetails &noPartyDetails) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noPartyDetails; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoTrdRegPublications": [)"; + writer.noTrdRegPublications().forEach( + [&](NoTrdRegPublications &noTrdRegPublications) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noTrdRegPublications; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} - void skip() { - noPartyDetails().forEach([](NoPartyDetails e) { e.skip(); }); - noTrdRegPublications().forEach([](NoTrdRegPublications e) { e.skip(); }); - } +void skip() +{ + auto &noPartyDetailsGroup { noPartyDetails() }; + while (noPartyDetailsGroup.hasNext()) + { + noPartyDetailsGroup.next().skip(); + } + auto &noTrdRegPublicationsGroup { noTrdRegPublications() }; + while (noTrdRegPublicationsGroup.hasNext()) + { + noTrdRegPublicationsGroup.next().skip(); + } +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoPartyDetailsLength = 0, - std::size_t NoTrdRegPublicationsLength = 0) { +SBE_NODISCARD static std::size_t computeLength( + std::size_t noPartyDetailsLength = 0, + std::size_t noTrdRegPublicationsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoPartyDetails::sbeHeaderSize(); - if (NoPartyDetailsLength > 254) { - throw std::runtime_error( - "NoPartyDetailsLength outside of allowed range [E110]"); - } - length += NoPartyDetailsLength * NoPartyDetails::sbeBlockLength(); + length += NoPartyDetails::sbeHeaderSize(); + if (noPartyDetailsLength > 254LL) + { + throw std::runtime_error("noPartyDetailsLength outside of allowed range [E110]"); + } + length += noPartyDetailsLength *NoPartyDetails::sbeBlockLength(); - length += NoTrdRegPublications::sbeHeaderSize(); - if (NoTrdRegPublicationsLength > 254) { - throw std::runtime_error( - "NoTrdRegPublicationsLength outside of allowed range [E110]"); - } - length += - NoTrdRegPublicationsLength * NoTrdRegPublications::sbeBlockLength(); - return length; + length += NoTrdRegPublications::sbeHeaderSize(); + if (noTrdRegPublicationsLength > 254LL) + { + throw std::runtime_error("noTrdRegPublicationsLength outside of allowed range [E110]"); + } + length += noTrdRegPublicationsLength *NoTrdRegPublications::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/PartyDetailsListReport538.h b/src/lib/orderman/ilink3/generated/PartyDetailsListReport538.h index f4e144924..29b21aa36 100644 --- a/src/lib/orderman/ilink3/generated/PartyDetailsListReport538.h +++ b/src/lib/orderman/ilink3/generated/PartyDetailsListReport538.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2758 +86,2974 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class PartyDetailsListReport538 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class PartyDetailsListReport538 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(93); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(538); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - PartyDetailsListReport538() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - PartyDetailsListReport538( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - PartyDetailsListReport538(char *buffer, const std::uint64_t bufferLength) - : PartyDetailsListReport538( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + PartyDetailsListReport538() = default; - PartyDetailsListReport538( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : PartyDetailsListReport538( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + PartyDetailsListReport538( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)93; - } + PartyDetailsListReport538(char *buffer, const std::uint64_t bufferLength) : + PartyDetailsListReport538(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + PartyDetailsListReport538( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + PartyDetailsListReport538(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)538; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(93); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(538); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "CG"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - PartyDetailsListReport538 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = PartyDetailsListReport538( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "CG"; + } - PartyDetailsListReport538 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + PartyDetailsListReport538 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = PartyDetailsListReport538(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = PartyDetailsListReport538( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + PartyDetailsListReport538 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - PartyDetailsListReport538 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = PartyDetailsListReport538( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = PartyDetailsListReport538( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + PartyDetailsListReport538 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = PartyDetailsListReport538(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + PartyDetailsListReport538 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - PartyDetailsListReport538 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + PartyDetailsListReport538 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - PartyDetailsListReport538 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + PartyDetailsListReport538 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsListReport538 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsListReport538 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *AvgPxGroupIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t avgPxGroupIDId() SBE_NOEXCEPT { - return 1731; - } + static SBE_CONSTEXPR std::uint16_t avgPxGroupIDId() SBE_NOEXCEPT + { + return 1731; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - avgPxGroupIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t avgPxGroupIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool avgPxGroupIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool avgPxGroupIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= avgPxGroupIDSinceVersion(); + return m_actingVersion >= avgPxGroupIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - avgPxGroupIDEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char avgPxGroupIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char avgPxGroupIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char avgPxGroupIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t avgPxGroupIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t avgPxGroupIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t avgPxGroupIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *avgPxGroupID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *avgPxGroupID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *avgPxGroupID() SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD char *avgPxGroupID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char avgPxGroupID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for avgPxGroupID [E104]"); - } + SBE_NODISCARD char avgPxGroupID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for avgPxGroupID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - PartyDetailsListReport538 & - avgPxGroupID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for avgPxGroupID [E105]"); - } + PartyDetailsListReport538 &avgPxGroupID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for avgPxGroupID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getAvgPxGroupID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getAvgPxGroupID [E106]"); - } + std::uint64_t getAvgPxGroupID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getAvgPxGroupID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - PartyDetailsListReport538 & - putAvgPxGroupID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 20); - return *this; - } + PartyDetailsListReport538 &putAvgPxGroupID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getAvgPxGroupIDAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getAvgPxGroupIDAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getAvgPxGroupIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAvgPxGroupIDAsString(); + std::string getAvgPxGroupIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAvgPxGroupIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAvgPxGroupIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - PartyDetailsListReport538 &putAvgPxGroupID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putAvgPxGroupID [E106]"); - } + #if __cplusplus >= 201703L + PartyDetailsListReport538 &putAvgPxGroupID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - PartyDetailsListReport538 &putAvgPxGroupID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putAvgPxGroupID [E106]"); - } + return *this; + } + #else + PartyDetailsListReport538 &putAvgPxGroupID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putAvgPxGroupID [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsListReport538 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsListReport538 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 32, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *PartyDetailsListReportIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReportIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t - partyDetailsListReportIDId() SBE_NOEXCEPT { - return 1510; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReportIDId() SBE_NOEXCEPT + { + return 1510; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReportIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReportIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReportIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReportIDSinceVersion(); + return m_actingVersion >= partyDetailsListReportIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReportIDEncodingOffset() SBE_NOEXCEPT { - return 40; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReportIDEncodingOffset() SBE_NOEXCEPT + { + return 40; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReportIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReportIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReportIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReportIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReportIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReportIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReportID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 40, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReportID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 40, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsListReport538 & - partyDetailsListReportID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 40, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsListReport538 &partyDetailsListReportID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 40, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 48; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsListReport538 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsListReport538 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SelfMatchPreventionIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SelfMatchPreventionIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t selfMatchPreventionIDId() SBE_NOEXCEPT { - return 2362; - } + static SBE_CONSTEXPR std::uint16_t selfMatchPreventionIDId() SBE_NOEXCEPT + { + return 2362; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool selfMatchPreventionIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool selfMatchPreventionIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= selfMatchPreventionIDSinceVersion(); + return m_actingVersion >= selfMatchPreventionIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - selfMatchPreventionIDEncodingOffset() SBE_NOEXCEPT { - return 56; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingOffset() SBE_NOEXCEPT + { + return 56; + } - static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t selfMatchPreventionIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t selfMatchPreventionIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t selfMatchPreventionID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t selfMatchPreventionID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsListReport538 & - selfMatchPreventionID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsListReport538 &selfMatchPreventionID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TotNumPartiesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TotNumPartiesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumPartiesId() SBE_NOEXCEPT { - return 1512; - } + static SBE_CONSTEXPR std::uint16_t totNumPartiesId() SBE_NOEXCEPT + { + return 1512; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumPartiesSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumPartiesSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumPartiesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumPartiesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumPartiesSinceVersion(); + return m_actingVersion >= totNumPartiesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumPartiesEncodingOffset() SBE_NOEXCEPT { - return 64; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumPartiesEncodingOffset() SBE_NOEXCEPT + { + return 64; + } - static SBE_CONSTEXPR std::uint16_t totNumPartiesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t totNumPartiesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t totNumPartiesMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t totNumPartiesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t totNumPartiesMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t totNumPartiesMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t totNumPartiesEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t totNumPartiesEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t totNumParties() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t totNumParties() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - PartyDetailsListReport538 & - totNumParties(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint16_t)); - return *this; - } + PartyDetailsListReport538 &totNumParties(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - RequestResultMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestResultMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestResultId() SBE_NOEXCEPT { - return 1511; - } + static SBE_CONSTEXPR std::uint16_t requestResultId() SBE_NOEXCEPT + { + return 1511; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestResultSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestResultSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestResultInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestResultInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestResultSinceVersion(); + return m_actingVersion >= requestResultSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestResultEncodingOffset() SBE_NOEXCEPT { - return 66; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestResultEncodingOffset() SBE_NOEXCEPT + { + return 66; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestResultEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestResultEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ReqResult::Value requestResult() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); - return ReqResult::get((val)); - } + SBE_NODISCARD std::uint8_t requestResultRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsListReport538 & - requestResult(const ReqResult::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ReqResult::Value requestResult() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return ReqResult::get((val)); + } - SBE_NODISCARD static const char * - LastFragmentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsListReport538 &requestResult(const ReqResult::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t lastFragmentId() SBE_NOEXCEPT { - return 893; - } + SBE_NODISCARD static const char *LastFragmentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastFragmentSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t lastFragmentId() SBE_NOEXCEPT + { + return 893; + } - SBE_NODISCARD bool lastFragmentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastFragmentSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastFragmentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastFragmentSinceVersion(); + return m_actingVersion >= lastFragmentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastFragmentEncodingOffset() SBE_NOEXCEPT { - return 67; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastFragmentEncodingOffset() SBE_NOEXCEPT + { + return 67; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastFragmentEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastFragmentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value lastFragment() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t lastFragmentRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsListReport538 & - lastFragment(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value lastFragment() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char *CustOrderCapacityMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsListReport538 &lastFragment(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t custOrderCapacityId() SBE_NOEXCEPT { - return 582; - } + SBE_NODISCARD static const char *CustOrderCapacityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - custOrderCapacitySinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t custOrderCapacityId() SBE_NOEXCEPT + { + return 582; + } - SBE_NODISCARD bool custOrderCapacityInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t custOrderCapacitySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool custOrderCapacityInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= custOrderCapacitySinceVersion(); + return m_actingVersion >= custOrderCapacitySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderCapacityEncodingOffset() SBE_NOEXCEPT { - return 68; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderCapacityEncodingOffset() SBE_NOEXCEPT + { + return 68; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderCapacityEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderCapacityEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD CustOrderCapacity::Value - custOrderCapacity() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 68, sizeof(std::uint8_t)); - return CustOrderCapacity::get((val)); - } + SBE_NODISCARD std::uint8_t custOrderCapacityRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 68, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsListReport538 & - custOrderCapacity(const CustOrderCapacity::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 68, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD CustOrderCapacity::Value custOrderCapacity() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 68, sizeof(std::uint8_t)); + return CustOrderCapacity::get((val)); + } - SBE_NODISCARD static const char *ClearingAccountTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsListReport538 &custOrderCapacity(const CustOrderCapacity::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 68, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t clearingAccountTypeId() SBE_NOEXCEPT { - return 1816; - } + SBE_NODISCARD static const char *ClearingAccountTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearingAccountTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t clearingAccountTypeId() SBE_NOEXCEPT + { + return 1816; + } - SBE_NODISCARD bool clearingAccountTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearingAccountTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clearingAccountTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearingAccountTypeSinceVersion(); + return m_actingVersion >= clearingAccountTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingAccountTypeEncodingOffset() SBE_NOEXCEPT { - return 69; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingAccountTypeEncodingOffset() SBE_NOEXCEPT + { + return 69; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingAccountTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingAccountTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ClearingAcctType::Value - clearingAccountType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t)); - return ClearingAcctType::get((val)); - } + SBE_NODISCARD std::uint8_t clearingAccountTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsListReport538 & - clearingAccountType(const ClearingAcctType::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ClearingAcctType::Value clearingAccountType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 69, sizeof(std::uint8_t)); + return ClearingAcctType::get((val)); + } - SBE_NODISCARD static const char *SelfMatchPreventionInstructionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsListReport538 &clearingAccountType(const ClearingAcctType::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 69, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t - selfMatchPreventionInstructionId() SBE_NOEXCEPT { - return 8000; - } + SBE_NODISCARD static const char *SelfMatchPreventionInstructionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - selfMatchPreventionInstructionSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t selfMatchPreventionInstructionId() SBE_NOEXCEPT + { + return 8000; + } - SBE_NODISCARD bool - selfMatchPreventionInstructionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t selfMatchPreventionInstructionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool selfMatchPreventionInstructionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= selfMatchPreventionInstructionSinceVersion(); + return m_actingVersion >= selfMatchPreventionInstructionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - selfMatchPreventionInstructionEncodingOffset() SBE_NOEXCEPT { - return 70; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t selfMatchPreventionInstructionEncodingOffset() SBE_NOEXCEPT + { + return 70; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - selfMatchPreventionInstructionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t selfMatchPreventionInstructionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SMPI::Value - selfMatchPreventionInstruction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 70, sizeof(char)); - return SMPI::get((val)); - } + SBE_NODISCARD char selfMatchPreventionInstructionRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 70, sizeof(char)); + return (val); + } - PartyDetailsListReport538 & - selfMatchPreventionInstruction(const SMPI::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 70, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD SMPI::Value selfMatchPreventionInstruction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 70, sizeof(char)); + return SMPI::get((val)); + } - SBE_NODISCARD static const char * - AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsListReport538 &selfMatchPreventionInstruction(const SMPI::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 70, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t avgPxIndicatorId() SBE_NOEXCEPT { - return 819; - } + SBE_NODISCARD static const char *AvgPxIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - avgPxIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t avgPxIndicatorId() SBE_NOEXCEPT + { + return 819; + } - SBE_NODISCARD bool avgPxIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t avgPxIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool avgPxIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= avgPxIndicatorSinceVersion(); + return m_actingVersion >= avgPxIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - avgPxIndicatorEncodingOffset() SBE_NOEXCEPT { - return 71; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t avgPxIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - avgPxIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t avgPxIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); - return AvgPxInd::get((val)); - } + SBE_NODISCARD std::uint8_t avgPxIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsListReport538 & - avgPxIndicator(const AvgPxInd::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 71, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD AvgPxInd::Value avgPxIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); + return AvgPxInd::get((val)); + } - SBE_NODISCARD static const char *ClearingTradePriceTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsListReport538 &avgPxIndicator(const AvgPxInd::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 71, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t clearingTradePriceTypeId() SBE_NOEXCEPT { - return 1598; - } + SBE_NODISCARD static const char *ClearingTradePriceTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearingTradePriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t clearingTradePriceTypeId() SBE_NOEXCEPT + { + return 1598; + } - SBE_NODISCARD bool clearingTradePriceTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearingTradePriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool clearingTradePriceTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearingTradePriceTypeSinceVersion(); + return m_actingVersion >= clearingTradePriceTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingTradePriceTypeEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingTradePriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearingTradePriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearingTradePriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SLEDS::Value clearingTradePriceType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 72, sizeof(std::uint8_t)); - return SLEDS::get((val)); - } + SBE_NODISCARD std::uint8_t clearingTradePriceTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 72, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsListReport538 & - clearingTradePriceType(const SLEDS::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 72, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SLEDS::Value clearingTradePriceType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 72, sizeof(std::uint8_t)); + return SLEDS::get((val)); + } - SBE_NODISCARD static const char * - CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsListReport538 &clearingTradePriceType(const SLEDS::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 72, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t cmtaGiveupCDId() SBE_NOEXCEPT { - return 9708; - } + SBE_NODISCARD static const char *CmtaGiveupCDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cmtaGiveupCDSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t cmtaGiveupCDId() SBE_NOEXCEPT + { + return 9708; + } - SBE_NODISCARD bool cmtaGiveupCDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cmtaGiveupCDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool cmtaGiveupCDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cmtaGiveupCDSinceVersion(); + return m_actingVersion >= cmtaGiveupCDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cmtaGiveupCDEncodingOffset() SBE_NOEXCEPT { - return 73; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cmtaGiveupCDEncodingOffset() SBE_NOEXCEPT + { + return 73; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cmtaGiveupCDEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cmtaGiveupCDEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 73, sizeof(char)); - return CmtaGiveUpCD::get((val)); - } + SBE_NODISCARD char cmtaGiveupCDRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 73, sizeof(char)); + return (val); + } - PartyDetailsListReport538 & - cmtaGiveupCD(const CmtaGiveUpCD::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 73, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD CmtaGiveUpCD::Value cmtaGiveupCD() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 73, sizeof(char)); + return CmtaGiveUpCD::get((val)); + } - SBE_NODISCARD static const char *CustOrderHandlingInstMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsListReport538 &cmtaGiveupCD(const CmtaGiveUpCD::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 73, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t custOrderHandlingInstId() SBE_NOEXCEPT { - return 1031; - } + SBE_NODISCARD static const char *CustOrderHandlingInstMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - custOrderHandlingInstSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t custOrderHandlingInstId() SBE_NOEXCEPT + { + return 1031; + } - SBE_NODISCARD bool custOrderHandlingInstInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t custOrderHandlingInstSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool custOrderHandlingInstInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= custOrderHandlingInstSinceVersion(); + return m_actingVersion >= custOrderHandlingInstSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderHandlingInstEncodingOffset() SBE_NOEXCEPT { - return 74; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderHandlingInstEncodingOffset() SBE_NOEXCEPT + { + return 74; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - custOrderHandlingInstEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t custOrderHandlingInstEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD CustOrdHandlInst::Value - custOrderHandlingInst() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 74, sizeof(char)); - return CustOrdHandlInst::get((val)); - } + SBE_NODISCARD char custOrderHandlingInstRaw() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 74, sizeof(char)); + return (val); + } - PartyDetailsListReport538 & - custOrderHandlingInst(const CustOrdHandlInst::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 74, &val, sizeof(char)); - return *this; - } + SBE_NODISCARD CustOrdHandlInst::Value custOrderHandlingInst() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 74, sizeof(char)); + return CustOrdHandlInst::get((val)); + } - SBE_NODISCARD static const char * - ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + PartyDetailsListReport538 &custOrderHandlingInst(const CustOrdHandlInst::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 74, &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t executorId() SBE_NOEXCEPT { return 5290; } + SBE_NODISCARD static const char *ExecutorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - executorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t executorId() SBE_NOEXCEPT + { + return 5290; + } - SBE_NODISCARD bool executorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t executorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool executorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= executorSinceVersion(); + return m_actingVersion >= executorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - executorEncodingOffset() SBE_NOEXCEPT { - return 75; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t executorEncodingOffset() SBE_NOEXCEPT + { + return 75; + } - static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t executorNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t executorMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t executorMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t executorEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t executor() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 75, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t executor() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 75, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsListReport538 &executor(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 75, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsListReport538 &executor(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 75, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *IDMShortCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t iDMShortCodeId() SBE_NOEXCEPT { - return 36023; - } + static SBE_CONSTEXPR std::uint16_t iDMShortCodeId() SBE_NOEXCEPT + { + return 36023; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - iDMShortCodeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t iDMShortCodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool iDMShortCodeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool iDMShortCodeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= iDMShortCodeSinceVersion(); + return m_actingVersion >= iDMShortCodeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - iDMShortCodeEncodingOffset() SBE_NOEXCEPT { - return 83; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingOffset() SBE_NOEXCEPT + { + return 83; + } - static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t iDMShortCodeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t iDMShortCodeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t iDMShortCodeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t iDMShortCodeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t iDMShortCode() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 83, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t iDMShortCode() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 83, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsListReport538 & - iDMShortCode(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 83, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsListReport538 &iDMShortCode(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 83, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 91; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 91; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsListReport538 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 91, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 91, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + PartyDetailsListReport538 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 91, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 92; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 92; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint8_t)); + return (val); + } - PartyDetailsListReport538 & - splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 92, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - class NoPartyDetails { + PartyDetailsListReport538 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 92, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoPartyDetails + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(22)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 22; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 22; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoPartyDetails &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *PartyDetailIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailIDId() SBE_NOEXCEPT + { + return 1691; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t partyDetailIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *partyDetailID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char *partyDetailID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char partyDetailID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for partyDetailID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } + + NoPartyDetails &partyDetailID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for partyDetailID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getPartyDetailID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getPartyDetailID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoPartyDetails &putPartyDetailID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getPartyDetailIDAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getPartyDetailIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getPartyDetailIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getPartyDetailIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoPartyDetails &putPartyDetailID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putPartyDetailID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoPartyDetails &putPartyDetailID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putPartyDetailID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailIDSourceId() SBE_NOEXCEPT + { + return 1692; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t partyDetailIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailIDSourceLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *partyDetailIDSource() const + { + static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 }; + + return (const char *)partyDetailIDSourceValues; + } + + SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const + { + static const std::uint8_t partyDetailIDSourceValues[] = { 67, 0 }; + + return (char)partyDetailIDSourceValues[index]; + } + + std::uint64_t getPartyDetailIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t partyDetailIDSourceValues[] = { 67 }; + std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) ? length : sizeof(partyDetailIDSourceValues); + + std::memcpy(dst, partyDetailIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getPartyDetailIDSourceAsString() const + { + static const std::uint8_t PartyDetailIDSourceValues[] = { 67 }; + + return std::string((const char *)PartyDetailIDSourceValues, 1); + } + + std::string getPartyDetailIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getPartyDetailIDSourceAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *PartyDetailRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailRoleId() SBE_NOEXCEPT + { + return 1693; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailRoleSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailRoleInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyDetailRoleSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailRoleEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailRoleEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t partyDetailRoleRaw() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + SBE_NODISCARD PartyDetailRole::Value partyDetailRole() const + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); + return PartyDetailRole::get(SBE_LITTLE_ENDIAN_ENCODE_16(val)); + } + + NoPartyDetails &partyDetailRole(const PartyDetailRole::Value value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint16_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoPartyDetails writer) + { + builder << '{'; + builder << R"("PartyDetailID": )"; + builder << '"' << + writer.getPartyDetailIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailRole": )"; + builder << '"' << writer.partyDetailRole() << '"'; + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)22); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 22; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoPartyDetails m_noPartyDetails; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 22; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoPartyDetailsId() SBE_NOEXCEPT + { + return 1671; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoPartyDetails &noPartyDetails() + { + m_noPartyDetails.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noPartyDetails; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoPartyDetails &noPartyDetailsCount(const std::uint8_t count) + { + m_noPartyDetails.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noPartyDetails; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noPartyDetailsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoPartyDetails &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *PartyDetailIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailIDId() SBE_NOEXCEPT { - return 1691; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noPartyDetailsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailIDSinceVersion(); + return m_actingVersion >= noPartyDetailsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char partyDetailIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char partyDetailIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char partyDetailIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - partyDetailIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t partyDetailIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *partyDetailID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *partyDetailID() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char partyDetailID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error( - "index out of range for partyDetailID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoPartyDetails & - partyDetailID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error( - "index out of range for partyDetailID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getPartyDetailID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getPartyDetailID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoPartyDetails &putPartyDetailID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getPartyDetailIDAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getPartyDetailIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getPartyDetailIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getPartyDetailIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoPartyDetails &putPartyDetailID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putPartyDetailID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoPartyDetails &putPartyDetailID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putPartyDetailID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailIDSourceMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailIDSourceId() SBE_NOEXCEPT { - return 1692; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailIDSourceEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR char partyDetailIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char partyDetailIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char partyDetailIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - partyDetailIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailIDSourceLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *partyDetailIDSource() const { - static const std::uint8_t partyDetailIDSourceValues[] = {67}; - - return (const char *)partyDetailIDSourceValues; - } - - SBE_NODISCARD char partyDetailIDSource(const std::uint64_t index) const { - static const std::uint8_t partyDetailIDSourceValues[] = {67}; - - return (char)partyDetailIDSourceValues[index]; - } - - std::uint64_t - getPartyDetailIDSource(char *dst, const std::uint64_t length) const { - static std::uint8_t partyDetailIDSourceValues[] = {67}; - std::uint64_t bytesToCopy = length < sizeof(partyDetailIDSourceValues) - ? length - : sizeof(partyDetailIDSourceValues); - - std::memcpy( - dst, partyDetailIDSourceValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getPartyDetailIDSourceAsString() const { - static const std::uint8_t PartyDetailIDSourceValues[] = {67}; - - return std::string((const char *)PartyDetailIDSourceValues, 1); - } - - std::string getPartyDetailIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getPartyDetailIDSourceAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char *PartyDetailRoleMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailRoleId() SBE_NOEXCEPT { - return 1693; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailRoleSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailRoleInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailRoleSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailRoleEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailRoleEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD PartyDetailRole::Value - partyDetailRole() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint16_t)); - return PartyDetailRole::get(SBE_LITTLE_ENDIAN_ENCODE_16(val)); - } - - NoPartyDetails & - partyDetailRole(const PartyDetailRole::Value value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint16_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoPartyDetails writer) { - builder << '{'; - builder << R"("PartyDetailID": )"; - builder << '"' << writer.getPartyDetailIDAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("PartyDetailRole": )"; - builder << '"' << writer.partyDetailRole() << '"'; - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoPartyDetails m_noPartyDetails; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoPartyDetailsId() SBE_NOEXCEPT { - return 1671; - } - - SBE_NODISCARD inline NoPartyDetails &noPartyDetails() { - m_noPartyDetails.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noPartyDetails; - } - - NoPartyDetails &noPartyDetailsCount(const std::uint8_t count) { - m_noPartyDetails.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noPartyDetails; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noPartyDetailsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noPartyDetailsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noPartyDetailsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoTrdRegPublications { + class NoTrdRegPublications + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)2); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 2; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoTrdRegPublications &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *TrdRegPublicationTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - trdRegPublicationTypeId() SBE_NOEXCEPT { - return 2669; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - trdRegPublicationTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool trdRegPublicationTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= trdRegPublicationTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - trdRegPublicationTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationTypeMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationTypeMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t trdRegPublicationType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); - return (val); - } - - NoTrdRegPublications & - trdRegPublicationType(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *TrdRegPublicationReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - trdRegPublicationReasonId() SBE_NOEXCEPT { - return 2670; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - trdRegPublicationReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool trdRegPublicationReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= trdRegPublicationReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - trdRegPublicationReasonEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - trdRegPublicationReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t trdRegPublicationReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint8_t)); - return (val); - } - - NoTrdRegPublications & - trdRegPublicationReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - NoTrdRegPublications writer) { - builder << '{'; - builder << R"("TrdRegPublicationType": )"; - builder << +writer.trdRegPublicationType(); - - builder << ", "; - builder << R"("TrdRegPublicationReason": )"; - builder << +writer.trdRegPublicationReason(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoTrdRegPublications m_noTrdRegPublications; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoTrdRegPublicationsId() SBE_NOEXCEPT { - return 2668; - } - - SBE_NODISCARD inline NoTrdRegPublications &noTrdRegPublications() { - m_noTrdRegPublications.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noTrdRegPublications; - } - - NoTrdRegPublications &noTrdRegPublicationsCount(const std::uint8_t count) { - m_noTrdRegPublications.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noTrdRegPublications; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noTrdRegPublicationsSinceVersion() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD bool noTrdRegPublicationsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noTrdRegPublicationsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - PartyDetailsListReport538 _writer) { - PartyDetailsListReport538 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "PartyDetailsListReport538", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); - - builder << ", "; - builder << R"("AvgPxGroupID": )"; - builder << '"' << writer.getAvgPxGroupIDAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("PartyDetailsListReportID": )"; - builder << +writer.partyDetailsListReportID(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("SelfMatchPreventionID": )"; - builder << +writer.selfMatchPreventionID(); - - builder << ", "; - builder << R"("TotNumParties": )"; - builder << +writer.totNumParties(); - - builder << ", "; - builder << R"("RequestResult": )"; - builder << '"' << writer.requestResult() << '"'; - - builder << ", "; - builder << R"("LastFragment": )"; - builder << '"' << writer.lastFragment() << '"'; - - builder << ", "; - builder << R"("CustOrderCapacity": )"; - builder << '"' << writer.custOrderCapacity() << '"'; - - builder << ", "; - builder << R"("ClearingAccountType": )"; - builder << '"' << writer.clearingAccountType() << '"'; - - builder << ", "; - builder << R"("SelfMatchPreventionInstruction": )"; - builder << '"' << writer.selfMatchPreventionInstruction() << '"'; - - builder << ", "; - builder << R"("AvgPxIndicator": )"; - builder << '"' << writer.avgPxIndicator() << '"'; - - builder << ", "; - builder << R"("ClearingTradePriceType": )"; - builder << '"' << writer.clearingTradePriceType() << '"'; - - builder << ", "; - builder << R"("CmtaGiveupCD": )"; - builder << '"' << writer.cmtaGiveupCD() << '"'; - - builder << ", "; - builder << R"("CustOrderHandlingInst": )"; - builder << '"' << writer.custOrderHandlingInst() << '"'; - - builder << ", "; - builder << R"("Executor": )"; - builder << +writer.executor(); - - builder << ", "; - builder << R"("IDMShortCode": )"; - builder << +writer.iDMShortCode(); - - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; - - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoPartyDetails": [)"; - writer.noPartyDetails().forEach([&](NoPartyDetails &noPartyDetails) { - if (atLeastOne) { - builder << ", "; + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - atLeastOne = true; - builder << noPartyDetails; - }); - builder << ']'; - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(2)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 2; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoTrdRegPublications": [)"; - writer.noTrdRegPublications().forEach( - [&](NoTrdRegPublications &noTrdRegPublications) { - if (atLeastOne) { - builder << ", "; + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoTrdRegPublications &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *TrdRegPublicationTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t trdRegPublicationTypeId() SBE_NOEXCEPT + { + return 2669; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t trdRegPublicationTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool trdRegPublicationTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= trdRegPublicationTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t trdRegPublicationTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t trdRegPublicationType() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); + return (val); + } + + NoTrdRegPublications &trdRegPublicationType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *TrdRegPublicationReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t trdRegPublicationReasonId() SBE_NOEXCEPT + { + return 2670; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t trdRegPublicationReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool trdRegPublicationReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= trdRegPublicationReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t trdRegPublicationReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t trdRegPublicationReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t trdRegPublicationReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint8_t)); + return (val); + } + + NoTrdRegPublications &trdRegPublicationReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoTrdRegPublications writer) + { + builder << '{'; + builder << R"("TrdRegPublicationType": )"; + builder << +writer.trdRegPublicationType(); + + builder << ", "; + builder << R"("TrdRegPublicationReason": )"; + builder << +writer.trdRegPublicationReason(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif + } + }; + +private: + NoTrdRegPublications m_noTrdRegPublications; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoTrdRegPublicationsId() SBE_NOEXCEPT + { + return 2668; + } + + SBE_NODISCARD inline NoTrdRegPublications &noTrdRegPublications() + { + m_noTrdRegPublications.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noTrdRegPublications; + } + + NoTrdRegPublications &noTrdRegPublicationsCount(const std::uint8_t count) + { + m_noTrdRegPublications.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noTrdRegPublications; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noTrdRegPublicationsSinceVersion() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD bool noTrdRegPublicationsInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noTrdRegPublicationsSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, PartyDetailsListReport538 _writer) +{ + PartyDetailsListReport538 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "PartyDetailsListReport538", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("AvgPxGroupID": )"; + builder << '"' << + writer.getAvgPxGroupIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("PartyDetailsListReportID": )"; + builder << +writer.partyDetailsListReportID(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("SelfMatchPreventionID": )"; + builder << +writer.selfMatchPreventionID(); + + builder << ", "; + builder << R"("TotNumParties": )"; + builder << +writer.totNumParties(); + + builder << ", "; + builder << R"("RequestResult": )"; + builder << '"' << writer.requestResult() << '"'; + + builder << ", "; + builder << R"("LastFragment": )"; + builder << '"' << writer.lastFragment() << '"'; + + builder << ", "; + builder << R"("CustOrderCapacity": )"; + builder << '"' << writer.custOrderCapacity() << '"'; + + builder << ", "; + builder << R"("ClearingAccountType": )"; + builder << '"' << writer.clearingAccountType() << '"'; + + builder << ", "; + builder << R"("SelfMatchPreventionInstruction": )"; + builder << '"' << writer.selfMatchPreventionInstruction() << '"'; + + builder << ", "; + builder << R"("AvgPxIndicator": )"; + builder << '"' << writer.avgPxIndicator() << '"'; + + builder << ", "; + builder << R"("ClearingTradePriceType": )"; + builder << '"' << writer.clearingTradePriceType() << '"'; + + builder << ", "; + builder << R"("CmtaGiveupCD": )"; + builder << '"' << writer.cmtaGiveupCD() << '"'; + + builder << ", "; + builder << R"("CustOrderHandlingInst": )"; + builder << '"' << writer.custOrderHandlingInst() << '"'; + + builder << ", "; + builder << R"("Executor": )"; + builder << +writer.executor(); + + builder << ", "; + builder << R"("IDMShortCode": )"; + builder << +writer.iDMShortCode(); + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoPartyDetails": [)"; + writer.noPartyDetails().forEach( + [&](NoPartyDetails &noPartyDetails) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noPartyDetails; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoTrdRegPublications": [)"; + writer.noTrdRegPublications().forEach( + [&](NoTrdRegPublications &noTrdRegPublications) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noTrdRegPublications; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} - void skip() { - noPartyDetails().forEach([](NoPartyDetails e) { e.skip(); }); - noTrdRegPublications().forEach([](NoTrdRegPublications e) { e.skip(); }); - } +void skip() +{ + auto &noPartyDetailsGroup { noPartyDetails() }; + while (noPartyDetailsGroup.hasNext()) + { + noPartyDetailsGroup.next().skip(); + } + auto &noTrdRegPublicationsGroup { noTrdRegPublications() }; + while (noTrdRegPublicationsGroup.hasNext()) + { + noTrdRegPublicationsGroup.next().skip(); + } +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoPartyDetailsLength = 0, - std::size_t NoTrdRegPublicationsLength = 0) { +SBE_NODISCARD static std::size_t computeLength( + std::size_t noPartyDetailsLength = 0, + std::size_t noTrdRegPublicationsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoPartyDetails::sbeHeaderSize(); - if (NoPartyDetailsLength > 254) { - throw std::runtime_error( - "NoPartyDetailsLength outside of allowed range [E110]"); - } - length += NoPartyDetailsLength * NoPartyDetails::sbeBlockLength(); + length += NoPartyDetails::sbeHeaderSize(); + if (noPartyDetailsLength > 254LL) + { + throw std::runtime_error("noPartyDetailsLength outside of allowed range [E110]"); + } + length += noPartyDetailsLength *NoPartyDetails::sbeBlockLength(); - length += NoTrdRegPublications::sbeHeaderSize(); - if (NoTrdRegPublicationsLength > 254) { - throw std::runtime_error( - "NoTrdRegPublicationsLength outside of allowed range [E110]"); - } - length += - NoTrdRegPublicationsLength * NoTrdRegPublications::sbeBlockLength(); - return length; + length += NoTrdRegPublications::sbeHeaderSize(); + if (noTrdRegPublicationsLength > 254LL) + { + throw std::runtime_error("noTrdRegPublicationsLength outside of allowed range [E110]"); + } + length += noTrdRegPublicationsLength *NoTrdRegPublications::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/PartyDetailsListRequest537.h b/src/lib/orderman/ilink3/generated/PartyDetailsListRequest537.h index f38b595a7..7b27ca5c2 100644 --- a/src/lib/orderman/ilink3/generated/PartyDetailsListRequest537.h +++ b/src/lib/orderman/ilink3/generated/PartyDetailsListRequest537.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1500 +86,1630 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class PartyDetailsListRequest537 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class PartyDetailsListRequest537 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(20); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(537); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - PartyDetailsListRequest537() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - PartyDetailsListRequest537( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - PartyDetailsListRequest537(char *buffer, const std::uint64_t bufferLength) - : PartyDetailsListRequest537( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + PartyDetailsListRequest537() = default; - PartyDetailsListRequest537( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : PartyDetailsListRequest537( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + PartyDetailsListRequest537( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)20; - } + PartyDetailsListRequest537(char *buffer, const std::uint64_t bufferLength) : + PartyDetailsListRequest537(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + PartyDetailsListRequest537( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + PartyDetailsListRequest537(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)537; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(20); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(537); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "CF"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - PartyDetailsListRequest537 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = PartyDetailsListRequest537( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "CF"; + } - PartyDetailsListRequest537 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + PartyDetailsListRequest537 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = PartyDetailsListRequest537(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = PartyDetailsListRequest537( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + PartyDetailsListRequest537 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - PartyDetailsListRequest537 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = PartyDetailsListRequest537( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = PartyDetailsListRequest537( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + PartyDetailsListRequest537 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = PartyDetailsListRequest537(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + PartyDetailsListRequest537 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - PartyDetailsListRequest537 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + PartyDetailsListRequest537 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsListRequest537 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsListRequest537 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - PartyDetailsListRequest537 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + PartyDetailsListRequest537 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - PartyDetailsListRequest537 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint32_t)); - return *this; - } + PartyDetailsListRequest537 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint32_t)); + return *this; + } - class NoRequestingPartyIDs { + class NoRequestingPartyIDs + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)7); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 7; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoRequestingPartyIDs &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *RequestingPartyIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t requestingPartyIDId() SBE_NOEXCEPT { - return 1658; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestingPartyIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool requestingPartyIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= requestingPartyIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestingPartyIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char requestingPartyIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char requestingPartyIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char requestingPartyIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - requestingPartyIDEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t - requestingPartyIDLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *requestingPartyID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *requestingPartyID() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char requestingPartyID(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error( - "index out of range for requestingPartyID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoRequestingPartyIDs & - requestingPartyID(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error( - "index out of range for requestingPartyID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getRequestingPartyID(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error( - "length too large for getRequestingPartyID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoRequestingPartyIDs & - putRequestingPartyID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getRequestingPartyIDAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getRequestingPartyIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getRequestingPartyIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(7)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 7; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - return oss.str(); - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getRequestingPartyIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 7; + } - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - return result; - } -#endif + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } -#if __cplusplus >= 201703L - NoRequestingPartyIDs &putRequestingPartyID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putRequestingPartyID [E106]"); - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - return *this; - } -#else - NoRequestingPartyIDs &putRequestingPartyID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putRequestingPartyID [E106]"); - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + inline NoRequestingPartyIDs &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - return *this; - } -#endif + return *this; + } - SBE_NODISCARD static const char *RequestingPartyIDSourceMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } - static SBE_CONSTEXPR std::uint16_t - requestingPartyIDSourceId() SBE_NOEXCEPT { - return 1659; - } + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestingPartyIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - SBE_NODISCARD bool requestingPartyIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= requestingPartyIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD static const char *RequestingPartyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestingPartyIDSourceEncodingOffset() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint16_t requestingPartyIDId() SBE_NOEXCEPT + { + return 1658; + } - static SBE_CONSTEXPR char - requestingPartyIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestingPartyIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char requestingPartyIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } + SBE_NODISCARD bool requestingPartyIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= requestingPartyIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - static SBE_CONSTEXPR char requestingPartyIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestingPartyIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::size_t - requestingPartyIDSourceEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR char requestingPartyIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - SBE_NODISCARD char requestingPartyIDSource() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); - return (val); - } + static SBE_CONSTEXPR char requestingPartyIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - NoRequestingPartyIDs & - requestingPartyIDSource(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); - return *this; - } + static SBE_CONSTEXPR char requestingPartyIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - SBE_NODISCARD static const char *RequestingPartyRoleMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::size_t requestingPartyIDEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint16_t requestingPartyRoleId() SBE_NOEXCEPT { - return 1660; - } + static SBE_CONSTEXPR std::uint64_t requestingPartyIDLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestingPartyRoleSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD const char *requestingPartyID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD bool requestingPartyRoleInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= requestingPartyRoleSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD char *requestingPartyID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestingPartyRoleEncodingOffset() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD char requestingPartyID(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for requestingPartyID [E104]"); + } - static SBE_CONSTEXPR char requestingPartyRoleNullValue() SBE_NOEXCEPT { - return (char)0; - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - static SBE_CONSTEXPR char requestingPartyRoleMinValue() SBE_NOEXCEPT { - return (char)32; - } + NoRequestingPartyIDs &requestingPartyID(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for requestingPartyID [E105]"); + } - static SBE_CONSTEXPR char requestingPartyRoleMaxValue() SBE_NOEXCEPT { - return (char)126; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - static SBE_CONSTEXPR std::size_t - requestingPartyRoleEncodingLength() SBE_NOEXCEPT { - return 1; - } + std::uint64_t getRequestingPartyID(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getRequestingPartyID [E106]"); + } - SBE_NODISCARD char requestingPartyRole() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 6, sizeof(char)); - return (val); - } + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - NoRequestingPartyIDs &requestingPartyRole(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 6, &val, sizeof(char)); - return *this; - } + NoRequestingPartyIDs &putRequestingPartyID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 5); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - NoRequestingPartyIDs writer) { - builder << '{'; - builder << R"("RequestingPartyID": )"; - builder << '"' - << writer.getRequestingPartyIDAsJsonEscapedString().c_str() - << '"'; + SBE_NODISCARD std::string getRequestingPartyIDAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - builder << ", "; - builder << R"("RequestingPartyIDSource": )"; - if (std::isprint(writer.requestingPartyIDSource())) { - builder << '"' << (char)writer.requestingPartyIDSource() << '"'; - } else { - builder << (int)writer.requestingPartyIDSource(); - } + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - builder << ", "; - builder << R"("RequestingPartyRole": )"; - if (std::isprint(writer.requestingPartyRole())) { - builder << '"' << (char)writer.requestingPartyRole() << '"'; - } else { - builder << (int)writer.requestingPartyRole(); - } + return result; + } - builder << '}'; + std::string getRequestingPartyIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getRequestingPartyIDAsString(); - return builder; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - void skip() {} + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return oss.str(); + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getRequestingPartyIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoRequestingPartyIDs &putRequestingPartyID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putRequestingPartyID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoRequestingPartyIDs &putRequestingPartyID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putRequestingPartyID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *RequestingPartyIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t requestingPartyIDSourceId() SBE_NOEXCEPT + { + return 1659; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestingPartyIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool requestingPartyIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= requestingPartyIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestingPartyIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR char requestingPartyIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char requestingPartyIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char requestingPartyIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t requestingPartyIDSourceEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char requestingPartyIDSource() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); + return (val); + } + + NoRequestingPartyIDs &requestingPartyIDSource(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *RequestingPartyRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t requestingPartyRoleId() SBE_NOEXCEPT + { + return 1660; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestingPartyRoleSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool requestingPartyRoleInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= requestingPartyRoleSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestingPartyRoleEncodingOffset() SBE_NOEXCEPT + { + return 6; + } + + static SBE_CONSTEXPR char requestingPartyRoleNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char requestingPartyRoleMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char requestingPartyRoleMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t requestingPartyRoleEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char requestingPartyRole() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 6, sizeof(char)); + return (val); + } + + NoRequestingPartyIDs &requestingPartyRole(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 6, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoRequestingPartyIDs writer) + { + builder << '{'; + builder << R"("RequestingPartyID": )"; + builder << '"' << + writer.getRequestingPartyIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("RequestingPartyIDSource": )"; + if (std::isprint(writer.requestingPartyIDSource())) + { + builder << '"' << (char)writer.requestingPartyIDSource() << '"'; + } + else + { + builder << (int)writer.requestingPartyIDSource(); + } + + builder << ", "; + builder << R"("RequestingPartyRole": )"; + if (std::isprint(writer.requestingPartyRole())) + { + builder << '"' << (char)writer.requestingPartyRole() << '"'; + } + else + { + builder << (int)writer.requestingPartyRole(); + } + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoRequestingPartyIDs m_noRequestingPartyIDs; +private: + NoRequestingPartyIDs m_noRequestingPartyIDs; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoRequestingPartyIDsId() SBE_NOEXCEPT { - return 1657; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoRequestingPartyIDsId() SBE_NOEXCEPT + { + return 1657; + } - SBE_NODISCARD inline NoRequestingPartyIDs &noRequestingPartyIDs() { - m_noRequestingPartyIDs.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noRequestingPartyIDs; - } + SBE_NODISCARD inline NoRequestingPartyIDs &noRequestingPartyIDs() + { + m_noRequestingPartyIDs.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRequestingPartyIDs; + } - NoRequestingPartyIDs &noRequestingPartyIDsCount(const std::uint8_t count) { - m_noRequestingPartyIDs.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noRequestingPartyIDs; - } + NoRequestingPartyIDs &noRequestingPartyIDsCount(const std::uint8_t count) + { + m_noRequestingPartyIDs.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRequestingPartyIDs; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noRequestingPartyIDsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noRequestingPartyIDsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noRequestingPartyIDsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noRequestingPartyIDsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noRequestingPartyIDsSinceVersion(); + return m_actingVersion >= noRequestingPartyIDsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoPartyIDs { + class NoPartyIDs + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(11)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 11; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 11; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoPartyIDs &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *PartyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyIDId() SBE_NOEXCEPT + { + return 448; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t partyIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoPartyIDs &partyID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *PartyIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyIDSourceId() SBE_NOEXCEPT + { + return 447; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR char partyIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char partyIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char partyIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t partyIDSourceEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD char partyIDSource() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(char)); + return (val); + } + + NoPartyIDs &partyIDSource(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *PartyRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyRoleId() SBE_NOEXCEPT + { + return 452; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyRoleSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyRoleInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= partyRoleSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyRoleEncodingOffset() SBE_NOEXCEPT + { + return 9; + } + + static SBE_CONSTEXPR std::uint16_t partyRoleNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } + + static SBE_CONSTEXPR std::uint16_t partyRoleMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t partyRoleMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t partyRoleEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t partyRole() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 9, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoPartyIDs &partyRole(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 9, &val, sizeof(std::uint16_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoPartyIDs writer) + { + builder << '{'; + builder << R"("PartyID": )"; + builder << +writer.partyID(); + + builder << ", "; + builder << R"("PartyIDSource": )"; + if (std::isprint(writer.partyIDSource())) + { + builder << '"' << (char)writer.partyIDSource() << '"'; + } + else + { + builder << (int)writer.partyIDSource(); + } + + builder << ", "; + builder << R"("PartyRole": )"; + builder << +writer.partyRole(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)11); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 11; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoPartyIDs m_noPartyIDs; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 11; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoPartyIDsId() SBE_NOEXCEPT + { + return 453; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoPartyIDs &noPartyIDs() + { + m_noPartyIDs.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noPartyIDs; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoPartyIDs &noPartyIDsCount(const std::uint8_t count) + { + m_noPartyIDs.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noPartyIDs; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noPartyIDsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoPartyIDs &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - PartyIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyIDId() SBE_NOEXCEPT { - return 448; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noPartyIDsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyIDSinceVersion(); + return m_actingVersion >= noPartyIDsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, PartyDetailsListRequest537 _writer) +{ + PartyDetailsListRequest537 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - static SBE_CONSTEXPR std::uint64_t partyIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + builder << '{'; + builder << R"("Name": "PartyDetailsListRequest537", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - static SBE_CONSTEXPR std::uint64_t partyIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - static SBE_CONSTEXPR std::uint64_t partyIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - static SBE_CONSTEXPR std::size_t partyIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - SBE_NODISCARD std::uint64_t partyID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoPartyIDs &partyID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *PartyIDSourceMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyIDSourceId() SBE_NOEXCEPT { - return 447; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyIDSourceEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR char partyIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char partyIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char partyIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - partyIDSourceEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD char partyIDSource() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(char)); - return (val); - } - - NoPartyIDs &partyIDSource(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - PartyRoleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyRoleId() SBE_NOEXCEPT { - return 452; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyRoleSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyRoleInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyRoleSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyRoleEncodingOffset() SBE_NOEXCEPT { - return 9; - } - - static SBE_CONSTEXPR std::uint16_t partyRoleNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } - - static SBE_CONSTEXPR std::uint16_t partyRoleMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t partyRoleMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t partyRoleEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t partyRole() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 9, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoPartyIDs &partyRole(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 9, &val, sizeof(std::uint16_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoPartyIDs writer) { - builder << '{'; - builder << R"("PartyID": )"; - builder << +writer.partyID(); - - builder << ", "; - builder << R"("PartyIDSource": )"; - if (std::isprint(writer.partyIDSource())) { - builder << '"' << (char)writer.partyIDSource() << '"'; - } else { - builder << (int)writer.partyIDSource(); - } - - builder << ", "; - builder << R"("PartyRole": )"; - builder << +writer.partyRole(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoPartyIDs m_noPartyIDs; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoPartyIDsId() SBE_NOEXCEPT { - return 453; - } - - SBE_NODISCARD inline NoPartyIDs &noPartyIDs() { - m_noPartyIDs.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noPartyIDs; - } - - NoPartyIDs &noPartyIDsCount(const std::uint8_t count) { - m_noPartyIDs.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noPartyIDs; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noPartyIDsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noPartyIDsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noPartyIDsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - PartyDetailsListRequest537 _writer) { - PartyDetailsListRequest537 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "PartyDetailsListRequest537", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoRequestingPartyIDs": [)"; - writer.noRequestingPartyIDs().forEach( - [&](NoRequestingPartyIDs &noRequestingPartyIDs) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoRequestingPartyIDs": [)"; + writer.noRequestingPartyIDs().forEach( + [&](NoRequestingPartyIDs &noRequestingPartyIDs) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noRequestingPartyIDs; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoPartyIDs": [)"; - writer.noPartyIDs().forEach([&](NoPartyIDs &noPartyIDs) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noPartyIDs; - }); - builder << ']'; - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoPartyIDs": [)"; + writer.noPartyIDs().forEach( + [&](NoPartyIDs &noPartyIDs) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noPartyIDs; + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} - void skip() { - noRequestingPartyIDs().forEach([](NoRequestingPartyIDs e) { e.skip(); }); - noPartyIDs().forEach([](NoPartyIDs e) { e.skip(); }); - } +void skip() +{ + auto &noRequestingPartyIDsGroup { noRequestingPartyIDs() }; + while (noRequestingPartyIDsGroup.hasNext()) + { + noRequestingPartyIDsGroup.next().skip(); + } + auto &noPartyIDsGroup { noPartyIDs() }; + while (noPartyIDsGroup.hasNext()) + { + noPartyIDsGroup.next().skip(); + } +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoRequestingPartyIDsLength = 0, - std::size_t NoPartyIDsLength = 0) { +SBE_NODISCARD static std::size_t computeLength( + std::size_t noRequestingPartyIDsLength = 0, + std::size_t noPartyIDsLength = 0) +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoRequestingPartyIDs::sbeHeaderSize(); - if (NoRequestingPartyIDsLength > 254) { - throw std::runtime_error( - "NoRequestingPartyIDsLength outside of allowed range [E110]"); - } - length += - NoRequestingPartyIDsLength * NoRequestingPartyIDs::sbeBlockLength(); + length += NoRequestingPartyIDs::sbeHeaderSize(); + if (noRequestingPartyIDsLength > 254LL) + { + throw std::runtime_error("noRequestingPartyIDsLength outside of allowed range [E110]"); + } + length += noRequestingPartyIDsLength *NoRequestingPartyIDs::sbeBlockLength(); - length += NoPartyIDs::sbeHeaderSize(); - if (NoPartyIDsLength > 254) { - throw std::runtime_error( - "NoPartyIDsLength outside of allowed range [E110]"); - } - length += NoPartyIDsLength * NoPartyIDs::sbeBlockLength(); - return length; + length += NoPartyIDs::sbeHeaderSize(); + if (noPartyIDsLength > 254LL) + { + throw std::runtime_error("noPartyIDsLength outside of allowed range [E110]"); + } + length += noPartyIDsLength *NoPartyIDs::sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/QuoteAckStatus.h b/src/lib/orderman/ilink3/generated/QuoteAckStatus.h index c22db0973..135068561 100644 --- a/src/lib/orderman/ilink3/generated/QuoteAckStatus.h +++ b/src/lib/orderman/ilink3/generated/QuoteAckStatus.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_QUOTEACKSTATUS_H_ #define _ILINKBINARY_QUOTEACKSTATUS_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class QuoteAckStatus { - public: - enum Value { - Accepted = (std::uint8_t)0, - Rejected = (std::uint8_t)5, - NULL_VALUE = (std::uint8_t)255 - }; +class QuoteAckStatus +{ +public: + enum Value + { + Accepted = static_cast(0), + Rejected = static_cast(5), + NULL_VALUE = static_cast(255) + }; - static QuoteAckStatus::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Accepted; - case 5: - return Rejected; - case 255: - return NULL_VALUE; - } + static QuoteAckStatus::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Accepted; + case static_cast(5): return Rejected; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum QuoteAckStatus [E103]"); - } + throw std::runtime_error("unknown value for enum QuoteAckStatus [E103]"); + } - static const char *c_str(const QuoteAckStatus::Value value) { - switch (value) { - case Accepted: - return "Accepted"; - case Rejected: - return "Rejected"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const QuoteAckStatus::Value value) + { + switch (value) + { + case Accepted: return "Accepted"; + case Rejected: return "Rejected"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum QuoteAckStatus [E103]:"); - } + throw std::runtime_error("unknown value for enum QuoteAckStatus [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, QuoteAckStatus::Value m) { - return os << QuoteAckStatus::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, QuoteAckStatus::Value m) + { + return os << QuoteAckStatus::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/QuoteCancel528.h b/src/lib/orderman/ilink3/generated/QuoteCancel528.h index 3f101602e..e7acd6559 100644 --- a/src/lib/orderman/ilink3/generated/QuoteCancel528.h +++ b/src/lib/orderman/ilink3/generated/QuoteCancel528.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2047 +86,2545 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class QuoteCancel528 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class QuoteCancel528 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(61); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(528); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - QuoteCancel528() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - QuoteCancel528( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - QuoteCancel528(char *buffer, const std::uint64_t bufferLength) - : QuoteCancel528( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + QuoteCancel528() = default; - QuoteCancel528( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : QuoteCancel528( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + QuoteCancel528( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)52; - } + QuoteCancel528(char *buffer, const std::uint64_t bufferLength) : + QuoteCancel528(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + QuoteCancel528( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + QuoteCancel528(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)528; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(61); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(528); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "Z"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - QuoteCancel528 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = QuoteCancel528( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "Z"; + } - QuoteCancel528 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + QuoteCancel528 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = QuoteCancel528(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = QuoteCancel528( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + QuoteCancel528 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - QuoteCancel528 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = QuoteCancel528( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = QuoteCancel528( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + QuoteCancel528 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = QuoteCancel528(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + QuoteCancel528 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - QuoteCancel528 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + QuoteCancel528 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - QuoteCancel528 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + QuoteCancel528 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - QuoteCancel528 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + QuoteCancel528 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - QuoteCancel528 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + QuoteCancel528 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - QuoteCancel528 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + QuoteCancel528 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - QuoteCancel528 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + QuoteCancel528 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - QuoteCancel528 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + QuoteCancel528 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - QuoteCancel528 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + QuoteCancel528 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - QuoteCancel528 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + QuoteCancel528 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 41; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 41; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 41; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 41; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 41 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 41 + (index * 1), sizeof(char)); + return (val); + } - QuoteCancel528 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + QuoteCancel528 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 41 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 41 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 41, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 41, sizeof(char) * static_cast(length)); + return length; + } - QuoteCancel528 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 41, src, sizeof(char) * 5); - return *this; - } + QuoteCancel528 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 41, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 41; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 41; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 41; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 41; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - QuoteCancel528 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + QuoteCancel528 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 41 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 41, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 41 + start] = 0; + } - return *this; - } -#else - QuoteCancel528 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + QuoteCancel528 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 41 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 41, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 41 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteIDId() SBE_NOEXCEPT { return 117; } + static SBE_CONSTEXPR std::uint16_t quoteIDId() SBE_NOEXCEPT + { + return 117; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteIDSinceVersion(); + return m_actingVersion >= quoteIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteIDEncodingOffset() SBE_NOEXCEPT { - return 46; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteIDEncodingOffset() SBE_NOEXCEPT + { + return 46; + } - static SBE_CONSTEXPR std::uint32_t quoteIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t quoteIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t quoteID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 46, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t quoteID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 46, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - QuoteCancel528 "eID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 46, &val, sizeof(std::uint32_t)); - return *this; - } + QuoteCancel528 "eID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 46, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *QuoteCancelTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteCancelTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteCancelTypeId() SBE_NOEXCEPT { - return 298; - } + static SBE_CONSTEXPR std::uint16_t quoteCancelTypeId() SBE_NOEXCEPT + { + return 298; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteCancelTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteCancelTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteCancelTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteCancelTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteCancelTypeSinceVersion(); + return m_actingVersion >= quoteCancelTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteCancelTypeEncodingOffset() SBE_NOEXCEPT { - return 50; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteCancelTypeEncodingOffset() SBE_NOEXCEPT + { + return 50; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteCancelTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteCancelTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD QuoteCxlTyp::Value quoteCancelType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 50, sizeof(std::uint8_t)); - return QuoteCxlTyp::get((val)); - } + SBE_NODISCARD std::uint8_t quoteCancelTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 50, sizeof(std::uint8_t)); + return (val); + } - QuoteCancel528 & - quoteCancelType(const QuoteCxlTyp::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 50, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD QuoteCxlTyp::Value quoteCancelType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 50, sizeof(std::uint8_t)); + return QuoteCxlTyp::get((val)); + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + QuoteCancel528 "eCancelType(const QuoteCxlTyp::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 50, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 51; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 51; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 51, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 51, sizeof(std::uint8_t)); + return (val); + } - QuoteCancel528 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 51, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 51, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - class NoQuoteEntries { + QuoteCancel528 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 51, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrigOrderUserMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origOrderUserId() SBE_NOEXCEPT + { + return 9937; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origOrderUserSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool origOrderUserInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origOrderUserSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origOrderUserEncodingOffset() SBE_NOEXCEPT + { + return 52; + } + + static SBE_CONSTEXPR char origOrderUserNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char origOrderUserMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char origOrderUserMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t origOrderUserEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t origOrderUserLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *origOrderUser() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 52; + } + + SBE_NODISCARD char *origOrderUser() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 52; + } + + SBE_NODISCARD char origOrderUser(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 52 + (index * 1), sizeof(char)); + return (val); + } + + QuoteCancel528 &origOrderUser(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 52 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrigOrderUser(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getOrigOrderUser [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 52, sizeof(char) * static_cast(length)); + return length; + } + + QuoteCancel528 &putOrigOrderUser(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 52, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getOrigOrderUserAsString() const + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrigOrderUserAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrigOrderUserAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrigOrderUserAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 52; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + QuoteCancel528 &putOrigOrderUser(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #else + QuoteCancel528 &putOrigOrderUser(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 52, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 52 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *QuoteEntryOpenMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteEntryOpenId() SBE_NOEXCEPT + { + return 9182; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteEntryOpenSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool quoteEntryOpenInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= quoteEntryOpenSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryOpenEncodingOffset() SBE_NOEXCEPT + { + return 60; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryOpenEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t quoteEntryOpenRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value quoteEntryOpen() const + { + if (m_actingVersion < 8) + { + return BooleanNULL::NULL_VALUE; + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 60, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + QuoteCancel528 "eEntryOpen(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 60, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoQuoteEntries + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)10); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 10; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 10; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoQuoteEntries &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *SecurityGroupMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT { - return 1151; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityGroupSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityGroupSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityGroupEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - securityGroupEncodingLength() SBE_NOEXCEPT { - return 6; - } - - static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT { - return 6; - } - - SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char securityGroup(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoQuoteEntries & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSecurityGroup(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error( - "length too large for getSecurityGroup [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoQuoteEntries &putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 6); - return *this; - } - - SBE_NODISCARD std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSecurityGroupAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityGroupAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(10)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 10; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - return oss.str(); - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 10; + } - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - return result; - } -#endif + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } -#if __cplusplus >= 201703L - NoQuoteEntries &putSecurityGroup(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - return *this; - } -#else - NoQuoteEntries &putSecurityGroup(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + inline NoQuoteEntries &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - return *this; - } -#endif + return *this; + } - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { - return 48; - } + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD static const char *SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT + { + return 1151; + } - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return 2147483647; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityGroupSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= securityGroupSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - NoQuoteEntries &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::int32_t)); - return *this; - } + static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoQuoteEntries writer) { - builder << '{'; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; + static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT + { + return 6; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT + { + return 6; + } - builder << '}'; + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - return builder; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - void skip() {} + SBE_NODISCARD char securityGroup(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E104]"); + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + NoQuoteEntries &securityGroup(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getSecurityGroup(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getSecurityGroup [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoQuoteEntries &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 6); + return *this; + } + + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSecurityGroupAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityGroupAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; + + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoQuoteEntries &putSecurityGroup(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoQuoteEntries &putSecurityGroup(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= securityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 6; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::int32_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoQuoteEntries writer) + { + builder << '{'; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoQuoteEntries m_noQuoteEntries; +private: + NoQuoteEntries m_noQuoteEntries; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoQuoteEntriesId() SBE_NOEXCEPT { - return 295; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoQuoteEntriesId() SBE_NOEXCEPT + { + return 295; + } - SBE_NODISCARD inline NoQuoteEntries &noQuoteEntries() { - m_noQuoteEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } + SBE_NODISCARD inline NoQuoteEntries &noQuoteEntries() + { + m_noQuoteEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteEntries; + } - NoQuoteEntries &noQuoteEntriesCount(const std::uint8_t count) { - m_noQuoteEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } + NoQuoteEntries &noQuoteEntriesCount(const std::uint8_t count) + { + m_noQuoteEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteEntries; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noQuoteEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noQuoteEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noQuoteEntriesInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noQuoteEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noQuoteEntriesSinceVersion(); + return m_actingVersion >= noQuoteEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - class NoQuoteSets { + class NoQuoteSets + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)10); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 10; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 10; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoQuoteSets &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - BidSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t bidSizeId() SBE_NOEXCEPT { - return 134; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - bidSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool bidSizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= bidSizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - bidSizeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t bidSize() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteSets &bidSize(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - OfferSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t offerSizeId() SBE_NOEXCEPT { - return 135; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - offerSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool offerSizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= offerSizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - offerSizeEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t offerSize() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteSets &offerSize(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDId() SBE_NOEXCEPT { - return 302; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteSetIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteSetIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteSetIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteSetIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t quoteSetID() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoQuoteSets "eSetID(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint16_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoQuoteSets writer) { - builder << '{'; - builder << R"("BidSize": )"; - builder << +writer.bidSize(); - - builder << ", "; - builder << R"("OfferSize": )"; - builder << +writer.offerSize(); - - builder << ", "; - builder << R"("QuoteSetID": )"; - builder << +writer.quoteSetID(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoQuoteSets m_noQuoteSets; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoQuoteSetsId() SBE_NOEXCEPT { - return 296; - } - - SBE_NODISCARD inline NoQuoteSets &noQuoteSets() { - m_noQuoteSets.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteSets; - } - - NoQuoteSets &noQuoteSetsCount(const std::uint8_t count) { - m_noQuoteSets.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteSets; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noQuoteSetsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noQuoteSetsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noQuoteSetsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, QuoteCancel528 _writer) { - QuoteCancel528 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "QuoteCancel528", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("QuoteID": )"; - builder << +writer.quoteID(); - - builder << ", "; - builder << R"("QuoteCancelType": )"; - builder << '"' << writer.quoteCancelType() << '"'; - - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoQuoteEntries": [)"; - writer.noQuoteEntries().forEach([&](NoQuoteEntries &noQuoteEntries) { - if (atLeastOne) { - builder << ", "; + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - atLeastOne = true; - builder << noQuoteEntries; - }); - builder << ']'; - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(10)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 10; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoQuoteSets": [)"; - writer.noQuoteSets().forEach([&](NoQuoteSets &noQuoteSets) { - if (atLeastOne) { - builder << ", "; + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 10; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); } - atLeastOne = true; - builder << noQuoteSets; - }); - builder << ']'; - } + return position; + } - builder << '}'; + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - return builder; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - void skip() { - noQuoteEntries().forEach([](NoQuoteEntries e) { e.skip(); }); - noQuoteSets().forEach([](NoQuoteSets e) { e.skip(); }); - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + inline NoQuoteSets &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoQuoteEntriesLength = 0, - std::size_t NoQuoteSetsLength = 0) { + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *BidSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t bidSizeId() SBE_NOEXCEPT + { + return 134; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t bidSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool bidSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= bidSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t bidSizeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint32_t bidSizeNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t bidSizeMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t bidSizeMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t bidSizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t bidSize() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteSets &bidSize(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *OfferSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t offerSizeId() SBE_NOEXCEPT + { + return 135; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t offerSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool offerSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= offerSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t offerSizeEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR std::uint32_t offerSizeNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t offerSizeMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t offerSizeMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t offerSizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t offerSize() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteSets &offerSize(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDId() SBE_NOEXCEPT + { + return 302; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteSetIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteSetIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteSetIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteSetIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t quoteSetID() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoQuoteSets "eSetID(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint16_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoQuoteSets writer) + { + builder << '{'; + builder << R"("BidSize": )"; + builder << +writer.bidSize(); + + builder << ", "; + builder << R"("OfferSize": )"; + builder << +writer.offerSize(); + + builder << ", "; + builder << R"("QuoteSetID": )"; + builder << +writer.quoteSetID(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoQuoteEntries::sbeHeaderSize(); - if (NoQuoteEntriesLength > 254) { - throw std::runtime_error( - "NoQuoteEntriesLength outside of allowed range [E110]"); - } - length += NoQuoteEntriesLength * NoQuoteEntries::sbeBlockLength(); - - length += NoQuoteSets::sbeHeaderSize(); - if (NoQuoteSetsLength > 254) { - throw std::runtime_error( - "NoQuoteSetsLength outside of allowed range [E110]"); - } - length += NoQuoteSetsLength * NoQuoteSets::sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } + } + }; + +private: + NoQuoteSets m_noQuoteSets; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoQuoteSetsId() SBE_NOEXCEPT + { + return 296; + } + + SBE_NODISCARD inline NoQuoteSets &noQuoteSets() + { + m_noQuoteSets.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteSets; + } + + NoQuoteSets &noQuoteSetsCount(const std::uint8_t count) + { + m_noQuoteSets.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteSets; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noQuoteSetsSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noQuoteSetsInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noQuoteSetsSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, QuoteCancel528 _writer) +{ + QuoteCancel528 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "QuoteCancel528", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("QuoteID": )"; + builder << +writer.quoteID(); + + builder << ", "; + builder << R"("QuoteCancelType": )"; + builder << '"' << writer.quoteCancelType() << '"'; + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("OrigOrderUser": )"; + builder << '"' << + writer.getOrigOrderUserAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("QuoteEntryOpen": )"; + builder << '"' << writer.quoteEntryOpen() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoQuoteEntries": [)"; + writer.noQuoteEntries().forEach( + [&](NoQuoteEntries &noQuoteEntries) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noQuoteEntries; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoQuoteSets": [)"; + writer.noQuoteSets().forEach( + [&](NoQuoteSets &noQuoteSets) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noQuoteSets; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noQuoteEntriesGroup { noQuoteEntries() }; + while (noQuoteEntriesGroup.hasNext()) + { + noQuoteEntriesGroup.next().skip(); + } + auto &noQuoteSetsGroup { noQuoteSets() }; + while (noQuoteSetsGroup.hasNext()) + { + noQuoteSetsGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noQuoteEntriesLength = 0, + std::size_t noQuoteSetsLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoQuoteEntries::sbeHeaderSize(); + if (noQuoteEntriesLength > 254LL) + { + throw std::runtime_error("noQuoteEntriesLength outside of allowed range [E110]"); + } + length += noQuoteEntriesLength *NoQuoteEntries::sbeBlockLength(); + + length += NoQuoteSets::sbeHeaderSize(); + if (noQuoteSetsLength > 254LL) + { + throw std::runtime_error("noQuoteSetsLength outside of allowed range [E110]"); + } + length += noQuoteSetsLength *NoQuoteSets::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/QuoteCancelAck547.h b/src/lib/orderman/ilink3/generated/QuoteCancelAck547.h deleted file mode 100644 index e96af4af9..000000000 --- a/src/lib/orderman/ilink3/generated/QuoteCancelAck547.h +++ /dev/null @@ -1,3051 +0,0 @@ -/* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_QUOTECANCELACK547_H_ -#define _ILINKBINARY_QUOTECANCELACK547_H_ - -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#include -#include -#include -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201703L -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - -#if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 -#endif -#include -#include -#include -#include - -#include -#include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif - -#define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() -#define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() -#define SBE_NULLVALUE_INT32 (std::numeric_limits::min)() -#define SBE_NULLVALUE_INT64 (std::numeric_limits::min)() -#define SBE_NULLVALUE_UINT8 (std::numeric_limits::max)() -#define SBE_NULLVALUE_UINT16 (std::numeric_limits::max)() -#define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() -#define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() - -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" -#include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" -#include "OrderTypeReq.h" -#include "PRICE9.h" -#include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" -#include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" -#include "TimeInForce.h" -#include "TradeAddendum.h" - -namespace iLinkBinary { - -class QuoteCancelAck547 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - QuoteCancelAck547() = default; - - QuoteCancelAck547( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - QuoteCancelAck547(char *buffer, const std::uint64_t bufferLength) - : QuoteCancelAck547( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - QuoteCancelAck547( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : QuoteCancelAck547( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)340; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)547; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)2; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "b"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - QuoteCancelAck547 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = QuoteCancelAck547( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - QuoteCancelAck547 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = QuoteCancelAck547( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - QuoteCancelAck547 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = QuoteCancelAck547( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - QuoteCancelAck547 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= uUIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - QuoteCancelAck547 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= textSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } - - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } - - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } - - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } - - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } - - QuoteCancelAck547 &text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } - - QuoteCancelAck547 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } - - std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); - - for (auto c = s.cbegin(); c != s.cend(); c++) { - switch (*c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - QuoteCancelAck547 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#else - QuoteCancelAck547 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 268; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } - - QuoteCancelAck547 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } - - QuoteCancelAck547 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 20); - return *this; - } - - std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (auto c = s.cbegin(); c != s.cend(); c++) { - switch (*c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - QuoteCancelAck547 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } - - return *this; - } -#else - QuoteCancelAck547 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 288; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 288, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - QuoteCancelAck547 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 288, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - RequestTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t requestTimeId() SBE_NOEXCEPT { - return 5979; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool requestTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= requestTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimeEncodingOffset() SBE_NOEXCEPT { - return 296; - } - - static SBE_CONSTEXPR std::uint64_t requestTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t requestTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 296, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - QuoteCancelAck547 &requestTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 296, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 304; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 304, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - QuoteCancelAck547 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 304, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *CancelledSymbolMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t cancelledSymbolId() SBE_NOEXCEPT { - return 9774; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cancelledSymbolSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool cancelledSymbolInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= cancelledSymbolSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cancelledSymbolEncodingOffset() SBE_NOEXCEPT { - return 312; - } - - static SBE_CONSTEXPR char cancelledSymbolNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char cancelledSymbolMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char cancelledSymbolMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - cancelledSymbolEncodingLength() SBE_NOEXCEPT { - return 6; - } - - static SBE_CONSTEXPR std::uint64_t cancelledSymbolLength() SBE_NOEXCEPT { - return 6; - } - - SBE_NODISCARD const char *cancelledSymbol() const SBE_NOEXCEPT { - return m_buffer + m_offset + 312; - } - - SBE_NODISCARD char *cancelledSymbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 312; - } - - SBE_NODISCARD char cancelledSymbol(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error( - "index out of range for cancelledSymbol [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 312 + (index * 1), sizeof(char)); - return (val); - } - - QuoteCancelAck547 & - cancelledSymbol(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for cancelledSymbol [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 312 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getCancelledSymbol(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error( - "length too large for getCancelledSymbol [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 312, - sizeof(char) * static_cast(length)); - return length; - } - - QuoteCancelAck547 &putCancelledSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 312, src, sizeof(char) * 6); - return *this; - } - - std::string getCancelledSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 312; - size_t length = 0; - - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getCancelledSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCancelledSymbolAsString(); - - for (auto c = s.cbegin(); c != s.cend(); c++) { - switch (*c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - std::string_view getCancelledSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 312; - size_t length = 0; - - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - QuoteCancelAck547 &putCancelledSymbol(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putCancelledSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 312, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 312 + start] = 0; - } - - return *this; - } -#else - QuoteCancelAck547 &putCancelledSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putCancelledSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 312, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 312 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 318; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 318; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 318; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 318 + (index * 1), sizeof(char)); - return (val); - } - - QuoteCancelAck547 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 318 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 318, - sizeof(char) * static_cast(length)); - return length; - } - - QuoteCancelAck547 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 318, src, sizeof(char) * 5); - return *this; - } - - std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 318; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (auto c = s.cbegin(); c != s.cend(); c++) { - switch (*c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 318; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - QuoteCancelAck547 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 318, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 318 + start] = 0; - } - - return *this; - } -#else - QuoteCancelAck547 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 318, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 318 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t quoteIDId() SBE_NOEXCEPT { return 117; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteIDEncodingOffset() SBE_NOEXCEPT { - return 323; - } - - static SBE_CONSTEXPR std::uint32_t quoteIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t quoteID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 323, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - QuoteCancelAck547 "eID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 323, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char *QuoteRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonId() SBE_NOEXCEPT { - return 300; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteRejectReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteRejectReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 327; - } - - static SBE_CONSTEXPR std::uint16_t - quoteRejectReasonNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t - quoteRejectReasonEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t quoteRejectReason() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - QuoteCancelAck547 & - quoteRejectReason(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 327, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= delayDurationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 329; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - QuoteCancelAck547 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 329, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 331; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 331, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - QuoteCancelAck547 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 331, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - QuoteStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t quoteStatusId() SBE_NOEXCEPT { - return 297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteStatusInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteStatusSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteStatusEncodingOffset() SBE_NOEXCEPT { - return 332; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD QuoteCxlStatus::Value quoteStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 332, sizeof(std::uint8_t)); - return QuoteCxlStatus::get((val)); - } - - QuoteCancelAck547 & - quoteStatus(const QuoteCxlStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 332, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *NoProcessedEntriesMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t noProcessedEntriesId() SBE_NOEXCEPT { - return 9772; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noProcessedEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noProcessedEntriesInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noProcessedEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - noProcessedEntriesEncodingOffset() SBE_NOEXCEPT { - return 333; - } - - static SBE_CONSTEXPR std::uint8_t - noProcessedEntriesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t noProcessedEntriesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t noProcessedEntriesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - noProcessedEntriesEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t noProcessedEntries() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint8_t)); - return (val); - } - - QuoteCancelAck547 & - noProcessedEntries(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 333, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MMProtectionResetMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t mMProtectionResetId() SBE_NOEXCEPT { - return 9773; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mMProtectionResetSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mMProtectionResetInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mMProtectionResetSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mMProtectionResetEncodingOffset() SBE_NOEXCEPT { - return 334; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mMProtectionResetEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 334, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - QuoteCancelAck547 & - mMProtectionReset(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 334, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *UnsolicitedCancelTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t unsolicitedCancelTypeId() SBE_NOEXCEPT { - return 9775; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unsolicitedCancelTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool unsolicitedCancelTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= unsolicitedCancelTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unsolicitedCancelTypeEncodingOffset() SBE_NOEXCEPT { - return 335; - } - - static SBE_CONSTEXPR char unsolicitedCancelTypeNullValue() SBE_NOEXCEPT { - return (char)48; - } - - static SBE_CONSTEXPR char unsolicitedCancelTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char unsolicitedCancelTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - unsolicitedCancelTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD char unsolicitedCancelType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 335, sizeof(char)); - return (val); - } - - QuoteCancelAck547 &unsolicitedCancelType(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 335, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= splitMsgSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 336; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 336, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } - - QuoteCancelAck547 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 336, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *TotNoQuoteEntriesMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t totNoQuoteEntriesId() SBE_NOEXCEPT { - return 304; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNoQuoteEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool totNoQuoteEntriesInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= totNoQuoteEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNoQuoteEntriesEncodingOffset() SBE_NOEXCEPT { - return 337; - } - - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } - - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t totNoQuoteEntries() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t)); - return (val); - } - - QuoteCancelAck547 &totNoQuoteEntries(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 337, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= liquidityFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 338; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 338, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } - - QuoteCancelAck547 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 338, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= possRetransFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 339; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - if (m_actingVersion < 2) { - return BooleanFlag::NULL_VALUE; - } - - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - QuoteCancelAck547 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 339, &val, sizeof(std::uint8_t)); - return *this; - } - - class NoQuoteEntries { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = std::numeric_limits::max(); - m_actingVersion = actingVersion; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)9); - dimensions.numInGroup((std::uint8_t)count); - m_index = std::numeric_limits::max(); - m_count = count; - m_blockLength = 9; - m_actingVersion = actingVersion; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } - - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index + 1 < m_count; - } - - inline NoQuoteEntries &next() { - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short to support next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *QuoteEntryIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t quoteEntryIDId() SBE_NOEXCEPT { - return 299; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteEntryIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteEntryIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteEntryIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteEntryIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t quoteEntryIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - quoteEntryIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t quoteEntryID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteEntries "eEntryID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { - return 48; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteEntries &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char *QuoteEntryRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t - quoteEntryRejectReasonId() SBE_NOEXCEPT { - return 368; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteEntryRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteEntryRejectReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteEntryRejectReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteEntryRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint8_t - quoteEntryRejectReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - quoteEntryRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - quoteEntryRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - quoteEntryRejectReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t quoteEntryRejectReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint8_t)); - return (val); - } - - NoQuoteEntries & - quoteEntryRejectReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoQuoteEntries writer) { - builder << '{'; - builder << R"("QuoteEntryID": )"; - builder << +writer.quoteEntryID(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("QuoteEntryRejectReason": )"; - builder << +writer.quoteEntryRejectReason(); - - builder << '}'; - - return builder; - } - }; - - private: - NoQuoteEntries m_noQuoteEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoQuoteEntriesId() SBE_NOEXCEPT { - return 295; - } - - SBE_NODISCARD inline NoQuoteEntries &noQuoteEntries() { - m_noQuoteEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } - - NoQuoteEntries &noQuoteEntriesCount(const std::uint8_t count) { - m_noQuoteEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noQuoteEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noQuoteEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noQuoteEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoQuoteSets { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = std::numeric_limits::max(); - m_actingVersion = actingVersion; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)4); - dimensions.numInGroup((std::uint8_t)count); - m_index = std::numeric_limits::max(); - m_count = count; - m_blockLength = 4; - m_actingVersion = actingVersion; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } - - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index + 1 < m_count; - } - - inline NoQuoteSets &next() { - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short to support next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDId() SBE_NOEXCEPT { - return 302; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteSetIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteSetIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteSetIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteSetIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t quoteSetID() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoQuoteSets "eSetID(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char *QuoteErrorCodeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::EPOCH: - return ""; - case MetaAttribute::TIME_UNIT: - return ""; - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - } - - return ""; - } - - static SBE_CONSTEXPR std::uint16_t quoteErrorCodeId() SBE_NOEXCEPT { - return 9030; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteErrorCodeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteErrorCodeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteErrorCodeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteErrorCodeEncodingOffset() SBE_NOEXCEPT { - return 2; - } - - static SBE_CONSTEXPR std::uint16_t - quoteErrorCodeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } - - static SBE_CONSTEXPR std::uint16_t quoteErrorCodeMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t quoteErrorCodeMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t - quoteErrorCodeEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t quoteErrorCode() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoQuoteSets "eErrorCode(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint16_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoQuoteSets writer) { - builder << '{'; - builder << R"("QuoteSetID": )"; - builder << +writer.quoteSetID(); - - builder << ", "; - builder << R"("QuoteErrorCode": )"; - builder << +writer.quoteErrorCode(); - - builder << '}'; - - return builder; - } - }; - - private: - NoQuoteSets m_noQuoteSets; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoQuoteSetsId() SBE_NOEXCEPT { - return 296; - } - - SBE_NODISCARD inline NoQuoteSets &noQuoteSets() { - m_noQuoteSets.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteSets; - } - - NoQuoteSets &noQuoteSetsCount(const std::uint8_t count) { - m_noQuoteSets.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteSets; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noQuoteSetsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noQuoteSetsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noQuoteSetsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, QuoteCancelAck547 _writer) { - QuoteCancelAck547 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "QuoteCancelAck547", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); - - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("RequestTime": )"; - builder << +writer.requestTime(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("CancelledSymbol": )"; - builder << '"' << writer.getCancelledSymbolAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("QuoteID": )"; - builder << +writer.quoteID(); - - builder << ", "; - builder << R"("QuoteRejectReason": )"; - builder << +writer.quoteRejectReason(); - - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("QuoteStatus": )"; - builder << '"' << writer.quoteStatus() << '"'; - - builder << ", "; - builder << R"("NoProcessedEntries": )"; - builder << +writer.noProcessedEntries(); - - builder << ", "; - builder << R"("MMProtectionReset": )"; - builder << '"' << writer.mMProtectionReset() << '"'; - - builder << ", "; - builder << R"("UnsolicitedCancelType": )"; - if (std::isprint(writer.unsolicitedCancelType())) { - builder << '"' << (char)writer.unsolicitedCancelType() << '"'; - } else { - builder << (int)writer.unsolicitedCancelType(); - } - - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; - - builder << ", "; - builder << R"("TotNoQuoteEntries": )"; - builder << +writer.totNoQuoteEntries(); - - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; - - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoQuoteEntries": [)"; - writer.noQuoteEntries().forEach([&](NoQuoteEntries &noQuoteEntries) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noQuoteEntries; - }); - builder << ']'; - } - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoQuoteSets": [)"; - writer.noQuoteSets().forEach([&](NoQuoteSets &noQuoteSets) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noQuoteSets; - }); - builder << ']'; - } - - builder << '}'; - - return builder; - } -}; -} // namespace iLinkBinary -#endif diff --git a/src/lib/orderman/ilink3/generated/QuoteCancelAck563.h b/src/lib/orderman/ilink3/generated/QuoteCancelAck563.h index dc0b73e05..9cb07698e 100644 --- a/src/lib/orderman/ilink3/generated/QuoteCancelAck563.h +++ b/src/lib/orderman/ilink3/generated/QuoteCancelAck563.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,3052 +86,3875 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class QuoteCancelAck563 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class QuoteCancelAck563 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(368); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(563); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - QuoteCancelAck563() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - QuoteCancelAck563( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - QuoteCancelAck563(char *buffer, const std::uint64_t bufferLength) - : QuoteCancelAck563( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + QuoteCancelAck563() = default; - QuoteCancelAck563( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : QuoteCancelAck563( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + QuoteCancelAck563( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)351; - } + QuoteCancelAck563(char *buffer, const std::uint64_t bufferLength) : + QuoteCancelAck563(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + QuoteCancelAck563( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + QuoteCancelAck563(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)563; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(368); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(563); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "b"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - QuoteCancelAck563 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = QuoteCancelAck563( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "b"; + } - QuoteCancelAck563 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + QuoteCancelAck563 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = QuoteCancelAck563(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = QuoteCancelAck563( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + QuoteCancelAck563 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - QuoteCancelAck563 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = QuoteCancelAck563( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = QuoteCancelAck563( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + QuoteCancelAck563 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = QuoteCancelAck563(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + QuoteCancelAck563 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - QuoteCancelAck563 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + QuoteCancelAck563 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - QuoteCancelAck563 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + QuoteCancelAck563 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - QuoteCancelAck563 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + QuoteCancelAck563 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } + static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT + { + return 58; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= textSinceVersion(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 256; + } - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 256; + } - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - QuoteCancelAck563 &text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } + QuoteCancelAck563 &text(const std::uint64_t index, const char value) + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } + std::uint64_t getText(char *const dst, const std::uint64_t length) const + { + if (length > 256) + { + throw std::runtime_error("length too large for getText [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - QuoteCancelAck563 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } + QuoteCancelAck563 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); + return *this; + } - SBE_NODISCARD std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); + std::string getTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTextAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - QuoteCancelAck563 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + #if __cplusplus >= 201703L + QuoteCancelAck563 &putText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - QuoteCancelAck563 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + return *this; + } + #else + QuoteCancelAck563 &putText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 268; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); + return (val); + } - QuoteCancelAck563 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + QuoteCancelAck563 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast(length)); + return length; + } - QuoteCancelAck563 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 20); - return *this; - } + QuoteCancelAck563 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - QuoteCancelAck563 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + QuoteCancelAck563 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#else - QuoteCancelAck563 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + QuoteCancelAck563 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 288; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 288; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 288, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 288, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - QuoteCancelAck563 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 288, &val, sizeof(std::uint64_t)); - return *this; - } + QuoteCancelAck563 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 288, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - RequestTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimeId() SBE_NOEXCEPT { - return 5979; - } + static SBE_CONSTEXPR std::uint16_t requestTimeId() SBE_NOEXCEPT + { + return 5979; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimeSinceVersion(); + return m_actingVersion >= requestTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimeEncodingOffset() SBE_NOEXCEPT { - return 296; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimeEncodingOffset() SBE_NOEXCEPT + { + return 296; + } - static SBE_CONSTEXPR std::uint64_t requestTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 296, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 296, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - QuoteCancelAck563 &requestTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 296, &val, sizeof(std::uint64_t)); - return *this; - } + QuoteCancelAck563 &requestTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 296, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 304; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 304; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 304, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 304, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - QuoteCancelAck563 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 304, &val, sizeof(std::uint64_t)); - return *this; - } + QuoteCancelAck563 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 304, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *CancelledSymbolMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CancelledSymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cancelledSymbolId() SBE_NOEXCEPT { - return 9774; - } + static SBE_CONSTEXPR std::uint16_t cancelledSymbolId() SBE_NOEXCEPT + { + return 9774; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cancelledSymbolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cancelledSymbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cancelledSymbolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cancelledSymbolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cancelledSymbolSinceVersion(); + return m_actingVersion >= cancelledSymbolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cancelledSymbolEncodingOffset() SBE_NOEXCEPT { - return 312; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cancelledSymbolEncodingOffset() SBE_NOEXCEPT + { + return 312; + } - static SBE_CONSTEXPR char cancelledSymbolNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char cancelledSymbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char cancelledSymbolMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char cancelledSymbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char cancelledSymbolMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char cancelledSymbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - cancelledSymbolEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t cancelledSymbolEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t cancelledSymbolLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::uint64_t cancelledSymbolLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *cancelledSymbol() const SBE_NOEXCEPT { - return m_buffer + m_offset + 312; - } + SBE_NODISCARD const char *cancelledSymbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 312; + } - SBE_NODISCARD char *cancelledSymbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 312; - } + SBE_NODISCARD char *cancelledSymbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 312; + } - SBE_NODISCARD char cancelledSymbol(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error( - "index out of range for cancelledSymbol [E104]"); - } + SBE_NODISCARD char cancelledSymbol(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cancelledSymbol [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 312 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 312 + (index * 1), sizeof(char)); + return (val); + } - QuoteCancelAck563 & - cancelledSymbol(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for cancelledSymbol [E105]"); - } + QuoteCancelAck563 &cancelledSymbol(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cancelledSymbol [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 312 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 312 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getCancelledSymbol(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error( - "length too large for getCancelledSymbol [E106]"); - } + std::uint64_t getCancelledSymbol(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getCancelledSymbol [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 312, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 312, sizeof(char) * static_cast(length)); + return length; + } - QuoteCancelAck563 &putCancelledSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 312, src, sizeof(char) * 6); - return *this; - } + QuoteCancelAck563 &putCancelledSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 312, src, sizeof(char) * 6); + return *this; + } - SBE_NODISCARD std::string getCancelledSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 312; - size_t length = 0; + SBE_NODISCARD std::string getCancelledSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 312; + std::size_t length = 0; - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getCancelledSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCancelledSymbolAsString(); + std::string getCancelledSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCancelledSymbolAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getCancelledSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 312; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCancelledSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 312; + std::size_t length = 0; - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - QuoteCancelAck563 &putCancelledSymbol(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putCancelledSymbol [E106]"); - } + #if __cplusplus >= 201703L + QuoteCancelAck563 &putCancelledSymbol(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCancelledSymbol [E106]"); + } - std::memcpy(m_buffer + m_offset + 312, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 312 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 312, str.data(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 312 + start] = 0; + } - return *this; - } -#else - QuoteCancelAck563 &putCancelledSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putCancelledSymbol [E106]"); - } + return *this; + } + #else + QuoteCancelAck563 &putCancelledSymbol(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCancelledSymbol [E106]"); + } - std::memcpy(m_buffer + m_offset + 312, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 312 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 312, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 312 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 318; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 318; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 318; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 318; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 318; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 318; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 318 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 318 + (index * 1), sizeof(char)); + return (val); + } - QuoteCancelAck563 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + QuoteCancelAck563 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 318 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 318 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 318, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 318, sizeof(char) * static_cast(length)); + return length; + } - QuoteCancelAck563 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 318, src, sizeof(char) * 5); - return *this; - } + QuoteCancelAck563 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 318, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 318; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 318; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 318; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 318; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - QuoteCancelAck563 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + QuoteCancelAck563 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 318, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 318 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 318, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 318 + start] = 0; + } - return *this; - } -#else - QuoteCancelAck563 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + QuoteCancelAck563 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 318, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 318 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 318, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 318 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteIDId() SBE_NOEXCEPT { return 117; } + static SBE_CONSTEXPR std::uint16_t quoteIDId() SBE_NOEXCEPT + { + return 117; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteIDSinceVersion(); + return m_actingVersion >= quoteIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteIDEncodingOffset() SBE_NOEXCEPT { - return 323; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteIDEncodingOffset() SBE_NOEXCEPT + { + return 323; + } - static SBE_CONSTEXPR std::uint32_t quoteIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t quoteIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t quoteIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t quoteIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t quoteIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t quoteID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 323, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t quoteID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 323, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - QuoteCancelAck563 "eID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 323, &val, sizeof(std::uint32_t)); - return *this; - } + QuoteCancelAck563 "eID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 323, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *QuoteRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonId() SBE_NOEXCEPT { - return 300; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonId() SBE_NOEXCEPT + { + return 300; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteRejectReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteRejectReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteRejectReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteRejectReasonSinceVersion(); + return m_actingVersion >= quoteRejectReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 327; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteRejectReasonEncodingOffset() SBE_NOEXCEPT + { + return 327; + } - static SBE_CONSTEXPR std::uint16_t - quoteRejectReasonNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - quoteRejectReasonEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t quoteRejectReasonEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t quoteRejectReason() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t quoteRejectReason() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 327, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - QuoteCancelAck563 & - quoteRejectReason(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 327, &val, sizeof(std::uint16_t)); - return *this; - } + QuoteCancelAck563 "eRejectReason(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 327, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 329; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 329; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - QuoteCancelAck563 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 329, &val, sizeof(std::uint16_t)); - return *this; - } + QuoteCancelAck563 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 329, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 331; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 331; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 331, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 331, sizeof(std::uint8_t)); + return (val); + } - QuoteCancelAck563 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 331, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 331, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - QuoteStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + QuoteCancelAck563 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 331, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t quoteStatusId() SBE_NOEXCEPT { - return 297; - } + SBE_NODISCARD static const char *QuoteStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t quoteStatusId() SBE_NOEXCEPT + { + return 297; + } - SBE_NODISCARD bool quoteStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteStatusSinceVersion(); + return m_actingVersion >= quoteStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteStatusEncodingOffset() SBE_NOEXCEPT { - return 332; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteStatusEncodingOffset() SBE_NOEXCEPT + { + return 332; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD QuoteCxlStatus::Value quoteStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 332, sizeof(std::uint8_t)); - return QuoteCxlStatus::get((val)); - } + SBE_NODISCARD std::uint8_t quoteStatusRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 332, sizeof(std::uint8_t)); + return (val); + } - QuoteCancelAck563 & - quoteStatus(const QuoteCxlStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 332, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD QuoteCxlStatus::Value quoteStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 332, sizeof(std::uint8_t)); + return QuoteCxlStatus::get((val)); + } - SBE_NODISCARD static const char *NoProcessedEntriesMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + QuoteCancelAck563 "eStatus(const QuoteCxlStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 332, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t noProcessedEntriesId() SBE_NOEXCEPT { - return 9772; - } + SBE_NODISCARD static const char *NoProcessedEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noProcessedEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t noProcessedEntriesId() SBE_NOEXCEPT + { + return 9772; + } - SBE_NODISCARD bool noProcessedEntriesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noProcessedEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noProcessedEntriesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noProcessedEntriesSinceVersion(); + return m_actingVersion >= noProcessedEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - noProcessedEntriesEncodingOffset() SBE_NOEXCEPT { - return 333; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t noProcessedEntriesEncodingOffset() SBE_NOEXCEPT + { + return 333; + } - static SBE_CONSTEXPR std::uint32_t - noProcessedEntriesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t noProcessedEntriesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t - noProcessedEntriesMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t noProcessedEntriesMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t - noProcessedEntriesMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t noProcessedEntriesMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t - noProcessedEntriesEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t noProcessedEntriesEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t noProcessedEntries() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t noProcessedEntries() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 333, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - QuoteCancelAck563 & - noProcessedEntries(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 333, &val, sizeof(std::uint32_t)); - return *this; - } + QuoteCancelAck563 &noProcessedEntries(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 333, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *MMProtectionResetMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MMProtectionResetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mMProtectionResetId() SBE_NOEXCEPT { - return 9773; - } + static SBE_CONSTEXPR std::uint16_t mMProtectionResetId() SBE_NOEXCEPT + { + return 9773; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mMProtectionResetSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mMProtectionResetSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mMProtectionResetInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mMProtectionResetInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mMProtectionResetSinceVersion(); + return m_actingVersion >= mMProtectionResetSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mMProtectionResetEncodingOffset() SBE_NOEXCEPT { - return 337; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mMProtectionResetEncodingOffset() SBE_NOEXCEPT + { + return 337; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mMProtectionResetEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mMProtectionResetEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t mMProtectionResetRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t)); + return (val); + } - QuoteCancelAck563 & - mMProtectionReset(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 337, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value mMProtectionReset() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 337, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char *UnsolicitedCancelTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + QuoteCancelAck563 &mMProtectionReset(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 337, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t unsolicitedCancelTypeId() SBE_NOEXCEPT { - return 9775; - } + SBE_NODISCARD static const char *UnsolicitedCancelTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unsolicitedCancelTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t unsolicitedCancelTypeId() SBE_NOEXCEPT + { + return 9775; + } - SBE_NODISCARD bool unsolicitedCancelTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unsolicitedCancelTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool unsolicitedCancelTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unsolicitedCancelTypeSinceVersion(); + return m_actingVersion >= unsolicitedCancelTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unsolicitedCancelTypeEncodingOffset() SBE_NOEXCEPT { - return 338; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unsolicitedCancelTypeEncodingOffset() SBE_NOEXCEPT + { + return 338; + } - static SBE_CONSTEXPR char unsolicitedCancelTypeNullValue() SBE_NOEXCEPT { - return (char)48; - } + static SBE_CONSTEXPR char unsolicitedCancelTypeNullValue() SBE_NOEXCEPT + { + return static_cast(48); + } - static SBE_CONSTEXPR char unsolicitedCancelTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char unsolicitedCancelTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char unsolicitedCancelTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char unsolicitedCancelTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - unsolicitedCancelTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t unsolicitedCancelTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char unsolicitedCancelType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 338, sizeof(char)); - return (val); - } + SBE_NODISCARD char unsolicitedCancelType() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 338, sizeof(char)); + return (val); + } - QuoteCancelAck563 &unsolicitedCancelType(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 338, &val, sizeof(char)); - return *this; - } + QuoteCancelAck563 &unsolicitedCancelType(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 338, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 339; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 339; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t)); + return (val); + } - QuoteCancelAck563 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 339, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 339, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char *TotNoQuoteEntriesMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + QuoteCancelAck563 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 339, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t totNoQuoteEntriesId() SBE_NOEXCEPT { - return 304; - } + SBE_NODISCARD static const char *TotNoQuoteEntriesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNoQuoteEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t totNoQuoteEntriesId() SBE_NOEXCEPT + { + return 304; + } - SBE_NODISCARD bool totNoQuoteEntriesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNoQuoteEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool totNoQuoteEntriesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNoQuoteEntriesSinceVersion(); + return m_actingVersion >= totNoQuoteEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNoQuoteEntriesEncodingOffset() SBE_NOEXCEPT { - return 340; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingOffset() SBE_NOEXCEPT + { + return 340; + } - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t totNoQuoteEntriesMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t totNoQuoteEntriesEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t totNoQuoteEntries() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 340, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t totNoQuoteEntries() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 340, sizeof(std::uint8_t)); + return (val); + } - QuoteCancelAck563 &totNoQuoteEntries(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 340, &val, sizeof(std::uint8_t)); - return *this; - } + QuoteCancelAck563 &totNoQuoteEntries(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 340, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LiquidityFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT { - return 9373; - } + static SBE_CONSTEXPR std::uint16_t liquidityFlagId() SBE_NOEXCEPT + { + return 9373; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - liquidityFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t liquidityFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool liquidityFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= liquidityFlagSinceVersion(); + return m_actingVersion >= liquidityFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingOffset() SBE_NOEXCEPT { - return 341; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingOffset() SBE_NOEXCEPT + { + return 341; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - liquidityFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t liquidityFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanNULL::Value liquidityFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 341, sizeof(std::uint8_t)); - return BooleanNULL::get((val)); - } + SBE_NODISCARD std::uint8_t liquidityFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 341, sizeof(std::uint8_t)); + return (val); + } - QuoteCancelAck563 & - liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 341, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanNULL::Value liquidityFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 341, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + QuoteCancelAck563 &liquidityFlag(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 341, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 342; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 342; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 342, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 342, sizeof(std::uint8_t)); + return (val); + } - QuoteCancelAck563 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 342, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 342, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + QuoteCancelAck563 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 342, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 343; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 343; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 343, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 343, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - QuoteCancelAck563 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 343, &val, sizeof(std::uint64_t)); - return *this; - } + QuoteCancelAck563 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 343, &val, sizeof(std::uint64_t)); + return *this; + } - class NoQuoteEntries { + SBE_NODISCARD static const char *OrigOrderUserMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t origOrderUserId() SBE_NOEXCEPT + { + return 9937; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t origOrderUserSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool origOrderUserInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= origOrderUserSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t origOrderUserEncodingOffset() SBE_NOEXCEPT + { + return 351; + } + + static SBE_CONSTEXPR char origOrderUserNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char origOrderUserMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char origOrderUserMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t origOrderUserEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t origOrderUserLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *origOrderUser() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 351; + } + + SBE_NODISCARD char *origOrderUser() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 351; + } + + SBE_NODISCARD char origOrderUser(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 351 + (index * 1), sizeof(char)); + return (val); + } + + QuoteCancelAck563 &origOrderUser(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for origOrderUser [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 351 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getOrigOrderUser(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getOrigOrderUser [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 351, sizeof(char) * static_cast(length)); + return length; + } + + QuoteCancelAck563 &putOrigOrderUser(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 351, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getOrigOrderUserAsString() const + { + const char *buffer = m_buffer + m_offset + 351; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getOrigOrderUserAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getOrigOrderUserAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getOrigOrderUserAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 351; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + QuoteCancelAck563 &putOrigOrderUser(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 351, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 351 + start] = 0; + } + + return *this; + } + #else + QuoteCancelAck563 &putOrigOrderUser(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putOrigOrderUser [E106]"); + } + + std::memcpy(m_buffer + m_offset + 351, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 351 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *CancelTextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t cancelTextId() SBE_NOEXCEPT + { + return 2807; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cancelTextSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool cancelTextInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= cancelTextSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cancelTextEncodingOffset() SBE_NOEXCEPT + { + return 359; + } + + static SBE_CONSTEXPR char cancelTextNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char cancelTextMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char cancelTextMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t cancelTextEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t cancelTextLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *cancelText() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 359; + } + + SBE_NODISCARD char *cancelText() SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return nullptr; + } + + return m_buffer + m_offset + 359; + } + + SBE_NODISCARD char cancelText(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E104]"); + } + + if (m_actingVersion < 8) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 359 + (index * 1), sizeof(char)); + return (val); + } + + QuoteCancelAck563 &cancelText(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for cancelText [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 359 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getCancelText(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getCancelText [E106]"); + } + + if (m_actingVersion < 8) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 359, sizeof(char) * static_cast(length)); + return length; + } + + QuoteCancelAck563 &putCancelText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 359, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getCancelTextAsString() const + { + const char *buffer = m_buffer + m_offset + 359; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getCancelTextAsJsonEscapedString() + { + if (m_actingVersion < 8) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getCancelTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCancelTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 359; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + QuoteCancelAck563 &putCancelText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 359, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 359 + start] = 0; + } + + return *this; + } + #else + QuoteCancelAck563 &putCancelText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putCancelText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 359, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 359 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *QuoteEntryOpenMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteEntryOpenId() SBE_NOEXCEPT + { + return 9182; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteEntryOpenSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool quoteEntryOpenInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= quoteEntryOpenSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryOpenEncodingOffset() SBE_NOEXCEPT + { + return 367; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryOpenEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t quoteEntryOpenRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 367, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanNULL::Value quoteEntryOpen() const + { + if (m_actingVersion < 8) + { + return BooleanNULL::NULL_VALUE; + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 367, sizeof(std::uint8_t)); + return BooleanNULL::get((val)); + } + + QuoteCancelAck563 "eEntryOpen(const BooleanNULL::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 367, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoQuoteEntries + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(9)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 9; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoQuoteEntries &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *QuoteEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteEntryIDId() SBE_NOEXCEPT + { + return 299; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteEntryIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteEntryIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteEntryIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint32_t quoteEntryIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t quoteEntryIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t quoteEntryID() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries "eEntryID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= securityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoQuoteEntries &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *QuoteEntryRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteEntryRejectReasonId() SBE_NOEXCEPT + { + return 368; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteEntryRejectReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteEntryRejectReasonInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteEntryRejectReasonSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteEntryRejectReasonEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint8_t quoteEntryRejectReasonNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t quoteEntryRejectReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t quoteEntryRejectReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t quoteEntryRejectReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t quoteEntryRejectReason() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint8_t)); + return (val); + } + + NoQuoteEntries "eEntryRejectReason(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoQuoteEntries writer) + { + builder << '{'; + builder << R"("QuoteEntryID": )"; + builder << +writer.quoteEntryID(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("QuoteEntryRejectReason": )"; + builder << +writer.quoteEntryRejectReason(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } + std::size_t length = sbeBlockLength(); + + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)9); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 9; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } +private: + NoQuoteEntries m_noQuoteEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 9; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoQuoteEntriesId() SBE_NOEXCEPT + { + return 295; + } - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } + SBE_NODISCARD inline NoQuoteEntries &noQuoteEntries() + { + m_noQuoteEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteEntries; + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoQuoteEntries &noQuoteEntriesCount(const std::uint8_t count) + { + m_noQuoteEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noQuoteEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoQuoteEntries &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char *QuoteEntryIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t quoteEntryIDId() SBE_NOEXCEPT { - return 299; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteEntryIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteEntryIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noQuoteEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteEntryIDSinceVersion(); + return m_actingVersion >= noQuoteEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteEntryIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t quoteEntryIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t quoteEntryIDMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t quoteEntryIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t - quoteEntryIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t quoteEntryID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteEntries "eEntryID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { - return 48; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoQuoteEntries &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char *QuoteEntryRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - quoteEntryRejectReasonId() SBE_NOEXCEPT { - return 368; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteEntryRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteEntryRejectReasonInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteEntryRejectReasonSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteEntryRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint8_t - quoteEntryRejectReasonNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t - quoteEntryRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - quoteEntryRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - quoteEntryRejectReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t quoteEntryRejectReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint8_t)); - return (val); - } - - NoQuoteEntries & - quoteEntryRejectReason(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoQuoteEntries writer) { - builder << '{'; - builder << R"("QuoteEntryID": )"; - builder << +writer.quoteEntryID(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("QuoteEntryRejectReason": )"; - builder << +writer.quoteEntryRejectReason(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoQuoteEntries m_noQuoteEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoQuoteEntriesId() SBE_NOEXCEPT { - return 295; - } - - SBE_NODISCARD inline NoQuoteEntries &noQuoteEntries() { - m_noQuoteEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } - - NoQuoteEntries &noQuoteEntriesCount(const std::uint8_t count) { - m_noQuoteEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noQuoteEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noQuoteEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noQuoteEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoQuoteSets { + class NoQuoteSets + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)4); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 4; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoQuoteSets &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDId() SBE_NOEXCEPT { - return 302; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteSetIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteSetIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteSetIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteSetIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t quoteSetID() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoQuoteSets "eSetID(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char *QuoteErrorCodeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t quoteErrorCodeId() SBE_NOEXCEPT { - return 9030; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteErrorCodeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteErrorCodeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteErrorCodeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteErrorCodeEncodingOffset() SBE_NOEXCEPT { - return 2; - } - - static SBE_CONSTEXPR std::uint16_t - quoteErrorCodeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } - - static SBE_CONSTEXPR std::uint16_t quoteErrorCodeMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t quoteErrorCodeMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t - quoteErrorCodeEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t quoteErrorCode() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoQuoteSets "eErrorCode(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint16_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoQuoteSets writer) { - builder << '{'; - builder << R"("QuoteSetID": )"; - builder << +writer.quoteSetID(); - - builder << ", "; - builder << R"("QuoteErrorCode": )"; - builder << +writer.quoteErrorCode(); - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoQuoteSets m_noQuoteSets; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoQuoteSetsId() SBE_NOEXCEPT { - return 296; - } - - SBE_NODISCARD inline NoQuoteSets &noQuoteSets() { - m_noQuoteSets.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteSets; - } - - NoQuoteSets &noQuoteSetsCount(const std::uint8_t count) { - m_noQuoteSets.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noQuoteSets; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noQuoteSetsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noQuoteSetsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noQuoteSetsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, QuoteCancelAck563 _writer) { - QuoteCancelAck563 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "QuoteCancelAck563", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); - - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("RequestTime": )"; - builder << +writer.requestTime(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("CancelledSymbol": )"; - builder << '"' << writer.getCancelledSymbolAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("QuoteID": )"; - builder << +writer.quoteID(); - - builder << ", "; - builder << R"("QuoteRejectReason": )"; - builder << +writer.quoteRejectReason(); - - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("QuoteStatus": )"; - builder << '"' << writer.quoteStatus() << '"'; - - builder << ", "; - builder << R"("NoProcessedEntries": )"; - builder << +writer.noProcessedEntries(); - - builder << ", "; - builder << R"("MMProtectionReset": )"; - builder << '"' << writer.mMProtectionReset() << '"'; - - builder << ", "; - builder << R"("UnsolicitedCancelType": )"; - if (std::isprint(writer.unsolicitedCancelType())) { - builder << '"' << (char)writer.unsolicitedCancelType() << '"'; - } else { - builder << (int)writer.unsolicitedCancelType(); - } - - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; - - builder << ", "; - builder << R"("TotNoQuoteEntries": )"; - builder << +writer.totNoQuoteEntries(); - - builder << ", "; - builder << R"("LiquidityFlag": )"; - builder << '"' << writer.liquidityFlag() << '"'; - - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; - - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoQuoteEntries": [)"; - writer.noQuoteEntries().forEach([&](NoQuoteEntries &noQuoteEntries) { - if (atLeastOne) { - builder << ", "; + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - atLeastOne = true; - builder << noQuoteEntries; - }); - builder << ']'; - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(4)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 4; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoQuoteSets": [)"; - writer.noQuoteSets().forEach([&](NoQuoteSets &noQuoteSets) { - if (atLeastOne) { - builder << ", "; + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); } - atLeastOne = true; - builder << noQuoteSets; - }); - builder << ']'; - } + return position; + } - builder << '}'; + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - return builder; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - void skip() { - noQuoteEntries().forEach([](NoQuoteEntries e) { e.skip(); }); - noQuoteSets().forEach([](NoQuoteSets e) { e.skip(); }); - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + inline NoQuoteSets &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength( - std::size_t NoQuoteEntriesLength = 0, - std::size_t NoQuoteSetsLength = 0) { + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *QuoteSetIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDId() SBE_NOEXCEPT + { + return 302; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteSetIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteSetIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteSetIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteSetIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t quoteSetIDMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t quoteSetIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t quoteSetID() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoQuoteSets "eSetID(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *QuoteErrorCodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t quoteErrorCodeId() SBE_NOEXCEPT + { + return 9030; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteErrorCodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteErrorCodeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteErrorCodeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteErrorCodeEncodingOffset() SBE_NOEXCEPT + { + return 2; + } + + static SBE_CONSTEXPR std::uint16_t quoteErrorCodeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } + + static SBE_CONSTEXPR std::uint16_t quoteErrorCodeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t quoteErrorCodeMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t quoteErrorCodeEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t quoteErrorCode() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoQuoteSets "eErrorCode(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint16_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoQuoteSets writer) + { + builder << '{'; + builder << R"("QuoteSetID": )"; + builder << +writer.quoteSetID(); + + builder << ", "; + builder << R"("QuoteErrorCode": )"; + builder << +writer.quoteErrorCode(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoQuoteEntries::sbeHeaderSize(); - if (NoQuoteEntriesLength > 254) { - throw std::runtime_error( - "NoQuoteEntriesLength outside of allowed range [E110]"); - } - length += NoQuoteEntriesLength * NoQuoteEntries::sbeBlockLength(); - - length += NoQuoteSets::sbeHeaderSize(); - if (NoQuoteSetsLength > 254) { - throw std::runtime_error( - "NoQuoteSetsLength outside of allowed range [E110]"); - } - length += NoQuoteSetsLength * NoQuoteSets::sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } + } + }; + +private: + NoQuoteSets m_noQuoteSets; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoQuoteSetsId() SBE_NOEXCEPT + { + return 296; + } + + SBE_NODISCARD inline NoQuoteSets &noQuoteSets() + { + m_noQuoteSets.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteSets; + } + + NoQuoteSets &noQuoteSetsCount(const std::uint8_t count) + { + m_noQuoteSets.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noQuoteSets; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noQuoteSetsSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noQuoteSetsInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noQuoteSetsSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, QuoteCancelAck563 _writer) +{ + QuoteCancelAck563 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "QuoteCancelAck563", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("RequestTime": )"; + builder << +writer.requestTime(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("CancelledSymbol": )"; + builder << '"' << + writer.getCancelledSymbolAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("QuoteID": )"; + builder << +writer.quoteID(); + + builder << ", "; + builder << R"("QuoteRejectReason": )"; + builder << +writer.quoteRejectReason(); + + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("QuoteStatus": )"; + builder << '"' << writer.quoteStatus() << '"'; + + builder << ", "; + builder << R"("NoProcessedEntries": )"; + builder << +writer.noProcessedEntries(); + + builder << ", "; + builder << R"("MMProtectionReset": )"; + builder << '"' << writer.mMProtectionReset() << '"'; + + builder << ", "; + builder << R"("UnsolicitedCancelType": )"; + if (std::isprint(writer.unsolicitedCancelType())) + { + builder << '"' << (char)writer.unsolicitedCancelType() << '"'; + } + else + { + builder << (int)writer.unsolicitedCancelType(); + } + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + builder << R"("TotNoQuoteEntries": )"; + builder << +writer.totNoQuoteEntries(); + + builder << ", "; + builder << R"("LiquidityFlag": )"; + builder << '"' << writer.liquidityFlag() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); + + builder << ", "; + builder << R"("OrigOrderUser": )"; + builder << '"' << + writer.getOrigOrderUserAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("CancelText": )"; + builder << '"' << + writer.getCancelTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("QuoteEntryOpen": )"; + builder << '"' << writer.quoteEntryOpen() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoQuoteEntries": [)"; + writer.noQuoteEntries().forEach( + [&](NoQuoteEntries &noQuoteEntries) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noQuoteEntries; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoQuoteSets": [)"; + writer.noQuoteSets().forEach( + [&](NoQuoteSets &noQuoteSets) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noQuoteSets; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noQuoteEntriesGroup { noQuoteEntries() }; + while (noQuoteEntriesGroup.hasNext()) + { + noQuoteEntriesGroup.next().skip(); + } + auto &noQuoteSetsGroup { noQuoteSets() }; + while (noQuoteSetsGroup.hasNext()) + { + noQuoteSetsGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noQuoteEntriesLength = 0, + std::size_t noQuoteSetsLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoQuoteEntries::sbeHeaderSize(); + if (noQuoteEntriesLength > 254LL) + { + throw std::runtime_error("noQuoteEntriesLength outside of allowed range [E110]"); + } + length += noQuoteEntriesLength *NoQuoteEntries::sbeBlockLength(); + + length += NoQuoteSets::sbeHeaderSize(); + if (noQuoteSetsLength > 254LL) + { + throw std::runtime_error("noQuoteSetsLength outside of allowed range [E110]"); + } + length += noQuoteSetsLength *NoQuoteSets::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/QuoteCxlStatus.h b/src/lib/orderman/ilink3/generated/QuoteCxlStatus.h index 34986af04..4d94f1b56 100644 --- a/src/lib/orderman/ilink3/generated/QuoteCxlStatus.h +++ b/src/lib/orderman/ilink3/generated/QuoteCxlStatus.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_QUOTECXLSTATUS_H_ #define _ILINKBINARY_QUOTECXLSTATUS_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,62 +25,57 @@ namespace iLinkBinary { -class QuoteCxlStatus { - public: - enum Value { - CancelperInstrument = (std::uint8_t)1, - CancelperInstrumentgroup = (std::uint8_t)3, - Cancelallquotes = (std::uint8_t)4, - Rejected = (std::uint8_t)5, - CancelperQuoteSet = (std::uint8_t)100, - NULL_VALUE = (std::uint8_t)255 - }; +class QuoteCxlStatus +{ +public: + enum Value + { + CancelperInstrument = static_cast(1), + CancelperInstrumentgroup = static_cast(3), + Cancelallquotes = static_cast(4), + Rejected = static_cast(5), + CancelperQuoteSet = static_cast(100), + NULL_VALUE = static_cast(255) + }; - static QuoteCxlStatus::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return CancelperInstrument; - case 3: - return CancelperInstrumentgroup; - case 4: - return Cancelallquotes; - case 5: - return Rejected; - case 100: - return CancelperQuoteSet; - case 255: - return NULL_VALUE; - } + static QuoteCxlStatus::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return CancelperInstrument; + case static_cast(3): return CancelperInstrumentgroup; + case static_cast(4): return Cancelallquotes; + case static_cast(5): return Rejected; + case static_cast(100): return CancelperQuoteSet; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum QuoteCxlStatus [E103]"); - } + throw std::runtime_error("unknown value for enum QuoteCxlStatus [E103]"); + } - static const char *c_str(const QuoteCxlStatus::Value value) { - switch (value) { - case CancelperInstrument: - return "CancelperInstrument"; - case CancelperInstrumentgroup: - return "CancelperInstrumentgroup"; - case Cancelallquotes: - return "Cancelallquotes"; - case Rejected: - return "Rejected"; - case CancelperQuoteSet: - return "CancelperQuoteSet"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const QuoteCxlStatus::Value value) + { + switch (value) + { + case CancelperInstrument: return "CancelperInstrument"; + case CancelperInstrumentgroup: return "CancelperInstrumentgroup"; + case Cancelallquotes: return "Cancelallquotes"; + case Rejected: return "Rejected"; + case CancelperQuoteSet: return "CancelperQuoteSet"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum QuoteCxlStatus [E103]:"); - } + throw std::runtime_error("unknown value for enum QuoteCxlStatus [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, QuoteCxlStatus::Value m) { - return os << QuoteCxlStatus::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, QuoteCxlStatus::Value m) + { + return os << QuoteCxlStatus::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/QuoteCxlTyp.h b/src/lib/orderman/ilink3/generated/QuoteCxlTyp.h index 88aef93b6..6f213e6a1 100644 --- a/src/lib/orderman/ilink3/generated/QuoteCxlTyp.h +++ b/src/lib/orderman/ilink3/generated/QuoteCxlTyp.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_QUOTECXLTYP_H_ #define _ILINKBINARY_QUOTECXLTYP_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,57 +25,54 @@ namespace iLinkBinary { -class QuoteCxlTyp { - public: - enum Value { - CancelperInstrument = (std::uint8_t)1, - CancelperInstrumentgroup = (std::uint8_t)3, - Cancelallquotes = (std::uint8_t)4, - CancelperQuoteSet = (std::uint8_t)100, - NULL_VALUE = (std::uint8_t)255 - }; +class QuoteCxlTyp +{ +public: + enum Value + { + CancelperInstrument = static_cast(1), + CancelperInstrumentgroup = static_cast(3), + Cancelallquotes = static_cast(4), + CancelperQuoteSet = static_cast(100), + NULL_VALUE = static_cast(255) + }; - static QuoteCxlTyp::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return CancelperInstrument; - case 3: - return CancelperInstrumentgroup; - case 4: - return Cancelallquotes; - case 100: - return CancelperQuoteSet; - case 255: - return NULL_VALUE; - } + static QuoteCxlTyp::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return CancelperInstrument; + case static_cast(3): return CancelperInstrumentgroup; + case static_cast(4): return Cancelallquotes; + case static_cast(100): return CancelperQuoteSet; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum QuoteCxlTyp [E103]"); - } + throw std::runtime_error("unknown value for enum QuoteCxlTyp [E103]"); + } - static const char *c_str(const QuoteCxlTyp::Value value) { - switch (value) { - case CancelperInstrument: - return "CancelperInstrument"; - case CancelperInstrumentgroup: - return "CancelperInstrumentgroup"; - case Cancelallquotes: - return "Cancelallquotes"; - case CancelperQuoteSet: - return "CancelperQuoteSet"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const QuoteCxlTyp::Value value) + { + switch (value) + { + case CancelperInstrument: return "CancelperInstrument"; + case CancelperInstrumentgroup: return "CancelperInstrumentgroup"; + case Cancelallquotes: return "Cancelallquotes"; + case CancelperQuoteSet: return "CancelperQuoteSet"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum QuoteCxlTyp [E103]:"); - } + throw std::runtime_error("unknown value for enum QuoteCxlTyp [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, QuoteCxlTyp::Value m) { - return os << QuoteCxlTyp::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, QuoteCxlTyp::Value m) + { + return os << QuoteCxlTyp::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/QuoteTyp.h b/src/lib/orderman/ilink3/generated/QuoteTyp.h index 6543bc76e..6ddc3ff01 100644 --- a/src/lib/orderman/ilink3/generated/QuoteTyp.h +++ b/src/lib/orderman/ilink3/generated/QuoteTyp.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_QUOTETYP_H_ #define _ILINKBINARY_QUOTETYP_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,39 +25,45 @@ namespace iLinkBinary { -class QuoteTyp { - public: - enum Value { Tradeable = (std::uint8_t)1, NULL_VALUE = (std::uint8_t)255 }; +class QuoteTyp +{ +public: + enum Value + { + Tradeable = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static QuoteTyp::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return Tradeable; - case 255: - return NULL_VALUE; - } + static QuoteTyp::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return Tradeable; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum QuoteTyp [E103]"); - } + throw std::runtime_error("unknown value for enum QuoteTyp [E103]"); + } - static const char *c_str(const QuoteTyp::Value value) { - switch (value) { - case Tradeable: - return "Tradeable"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const QuoteTyp::Value value) + { + switch (value) + { + case Tradeable: return "Tradeable"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum QuoteTyp [E103]:"); - } + throw std::runtime_error("unknown value for enum QuoteTyp [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, QuoteTyp::Value m) { - return os << QuoteTyp::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, QuoteTyp::Value m) + { + return os << QuoteTyp::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/README.txt b/src/lib/orderman/ilink3/generated/README.txt index 64d3df695..f8fd737e1 100644 --- a/src/lib/orderman/ilink3/generated/README.txt +++ b/src/lib/orderman/ilink3/generated/README.txt @@ -1,13 +1,11 @@ -To update ilinkbinary.xml -sftp cmeconfig@sftpng.cmegroup.com -password: G3t(0nnect3d -get /MSGW/NRCert/Templates/ilinkbinary.xml - -To generate: - -Download sbe-all-[version].jar from sbe-logic github releases. - -docker run --rm -it -w /work -v $PWD:/work java java -Dsbe.output.dir=/work -Dsbe.generate.ir="false" -Dsbe.target.language=cpp -jar sbe-all-1.16.1.jar ilinkbinary.xml -#docker run --rm -it -w /work -v $PWD:/work java java -Dsbe.output.dir=/work -Dsbe.generate.ir="false" -Dsbe.target.language=uk.co.real_logic.sbe.generation.rust.Rust -jar sbe-all-1.16.1.jar ilinkbinary.xml - - +To update ilinkbinary.xml +sftp cmeconfig@sftpng.cmegroup.com +password: G3t(0nnect3d +get /MSGW/NRCert/Templates/ilinkbinary.xml + +To generate: + +Download sbe-all-[version].jar from sbe-logic github releases. + +docker run --rm -it -w /work -v $PWD:/work eclipse-temurin:17-jdk-jammy java -Dsbe.output.dir=/work -Dsbe.generate.ir="false" -Dsbe.target.language=cpp -jar sbe-all-1.27.0.jar ilinkbinary.xml + diff --git a/src/lib/orderman/ilink3/generated/RFQSide.h b/src/lib/orderman/ilink3/generated/RFQSide.h index e950804a1..02e96ac82 100644 --- a/src/lib/orderman/ilink3/generated/RFQSide.h +++ b/src/lib/orderman/ilink3/generated/RFQSide.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_RFQSIDE_H_ #define _ILINKBINARY_RFQSIDE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,52 +25,51 @@ namespace iLinkBinary { -class RFQSide { - public: - enum Value { - Buy = (std::uint8_t)1, - Sell = (std::uint8_t)2, - Cross = (std::uint8_t)8, - NULL_VALUE = (std::uint8_t)255 - }; +class RFQSide +{ +public: + enum Value + { + Buy = static_cast(1), + Sell = static_cast(2), + Cross = static_cast(8), + NULL_VALUE = static_cast(255) + }; - static RFQSide::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return Buy; - case 2: - return Sell; - case 8: - return Cross; - case 255: - return NULL_VALUE; - } + static RFQSide::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return Buy; + case static_cast(2): return Sell; + case static_cast(8): return Cross; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum RFQSide [E103]"); - } + throw std::runtime_error("unknown value for enum RFQSide [E103]"); + } - static const char *c_str(const RFQSide::Value value) { - switch (value) { - case Buy: - return "Buy"; - case Sell: - return "Sell"; - case Cross: - return "Cross"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const RFQSide::Value value) + { + switch (value) + { + case Buy: return "Buy"; + case Sell: return "Sell"; + case Cross: return "Cross"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum RFQSide [E103]:"); - } + throw std::runtime_error("unknown value for enum RFQSide [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, RFQSide::Value m) { - return os << RFQSide::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, RFQSide::Value m) + { + return os << RFQSide::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ReqResult.h b/src/lib/orderman/ilink3/generated/ReqResult.h index b09bac895..1b4af8ced 100644 --- a/src/lib/orderman/ilink3/generated/ReqResult.h +++ b/src/lib/orderman/ilink3/generated/ReqResult.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_REQRESULT_H_ #define _ILINKBINARY_REQRESULT_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,57 +25,54 @@ namespace iLinkBinary { -class ReqResult { - public: - enum Value { - ValidRequest = (std::uint8_t)0, - NoDataFoundThatMatchedSelectionCriteria = (std::uint8_t)2, - NotAuthorizedtoRetrieveData = (std::uint8_t)3, - DataTemporarilyUnavailable = (std::uint8_t)4, - NULL_VALUE = (std::uint8_t)255 - }; +class ReqResult +{ +public: + enum Value + { + ValidRequest = static_cast(0), + NoDataFoundThatMatchedSelectionCriteria = static_cast(2), + NotAuthorizedtoRetrieveData = static_cast(3), + DataTemporarilyUnavailable = static_cast(4), + NULL_VALUE = static_cast(255) + }; - static ReqResult::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return ValidRequest; - case 2: - return NoDataFoundThatMatchedSelectionCriteria; - case 3: - return NotAuthorizedtoRetrieveData; - case 4: - return DataTemporarilyUnavailable; - case 255: - return NULL_VALUE; - } + static ReqResult::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return ValidRequest; + case static_cast(2): return NoDataFoundThatMatchedSelectionCriteria; + case static_cast(3): return NotAuthorizedtoRetrieveData; + case static_cast(4): return DataTemporarilyUnavailable; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ReqResult [E103]"); - } + throw std::runtime_error("unknown value for enum ReqResult [E103]"); + } - static const char *c_str(const ReqResult::Value value) { - switch (value) { - case ValidRequest: - return "ValidRequest"; - case NoDataFoundThatMatchedSelectionCriteria: - return "NoDataFoundThatMatchedSelectionCriteria"; - case NotAuthorizedtoRetrieveData: - return "NotAuthorizedtoRetrieveData"; - case DataTemporarilyUnavailable: - return "DataTemporarilyUnavailable"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ReqResult::Value value) + { + switch (value) + { + case ValidRequest: return "ValidRequest"; + case NoDataFoundThatMatchedSelectionCriteria: return "NoDataFoundThatMatchedSelectionCriteria"; + case NotAuthorizedtoRetrieveData: return "NotAuthorizedtoRetrieveData"; + case DataTemporarilyUnavailable: return "DataTemporarilyUnavailable"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum ReqResult [E103]:"); - } + throw std::runtime_error("unknown value for enum ReqResult [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ReqResult::Value m) { - return os << ReqResult::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ReqResult::Value m) + { + return os << ReqResult::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/RequestForQuote543.h b/src/lib/orderman/ilink3/generated/RequestForQuote543.h index 8bc6c85c2..4f0f062bf 100644 --- a/src/lib/orderman/ilink3/generated/RequestForQuote543.h +++ b/src/lib/orderman/ilink3/generated/RequestForQuote543.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1471 +86,1625 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class RequestForQuote543 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class RequestForQuote543 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(55); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(543); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - RequestForQuote543() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - RequestForQuote543( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - RequestForQuote543(char *buffer, const std::uint64_t bufferLength) - : RequestForQuote543( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + RequestForQuote543() = default; - RequestForQuote543( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : RequestForQuote543( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + RequestForQuote543( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)55; - } + RequestForQuote543(char *buffer, const std::uint64_t bufferLength) : + RequestForQuote543(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + RequestForQuote543( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + RequestForQuote543(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)543; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(55); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(543); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "R"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - RequestForQuote543 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = RequestForQuote543( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "R"; + } - RequestForQuote543 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + RequestForQuote543 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = RequestForQuote543(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = RequestForQuote543( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + RequestForQuote543 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - RequestForQuote543 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = RequestForQuote543( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = RequestForQuote543( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + RequestForQuote543 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = RequestForQuote543(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + RequestForQuote543 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - RequestForQuote543 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + RequestForQuote543 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RequestForQuote543 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + RequestForQuote543 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteReqIDId() SBE_NOEXCEPT { - return 131; - } + static SBE_CONSTEXPR std::uint16_t quoteReqIDId() SBE_NOEXCEPT + { + return 131; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteReqIDSinceVersion(); + return m_actingVersion >= quoteReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteReqIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteReqIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t quoteReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t quoteReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RequestForQuote543 "eReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + RequestForQuote543 "eReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } - RequestForQuote543 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + RequestForQuote543 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - RequestForQuote543 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } + RequestForQuote543 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } - RequestForQuote543 &senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + RequestForQuote543 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } - RequestForQuote543 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } + RequestForQuote543 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - RequestForQuote543 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + RequestForQuote543 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#else - RequestForQuote543 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + RequestForQuote543 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 41; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 41; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RequestForQuote543 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); - return *this; - } + RequestForQuote543 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 49; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 49; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); + return (val); + } - RequestForQuote543 &location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + RequestForQuote543 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 49, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast(length)); + return length; + } - RequestForQuote543 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 5); - return *this; - } + RequestForQuote543 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - RequestForQuote543 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + RequestForQuote543 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } - return *this; - } -#else - RequestForQuote543 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + RequestForQuote543 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - QuoteTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteTypeId() SBE_NOEXCEPT { return 537; } + static SBE_CONSTEXPR std::uint16_t quoteTypeId() SBE_NOEXCEPT + { + return 537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteTypeSinceVersion(); + return m_actingVersion >= quoteTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteTypeEncodingOffset() SBE_NOEXCEPT { - return 54; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteTypeEncodingOffset() SBE_NOEXCEPT + { + return 54; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD QuoteTyp::Value quoteType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 54, sizeof(std::uint8_t)); - return QuoteTyp::get((val)); - } + SBE_NODISCARD std::uint8_t quoteTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 54, sizeof(std::uint8_t)); + return (val); + } - RequestForQuote543 "eType(const QuoteTyp::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 54, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD QuoteTyp::Value quoteType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 54, sizeof(std::uint8_t)); + return QuoteTyp::get((val)); + } - class NoRelatedSym { + RequestForQuote543 "eType(const QuoteTyp::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 54, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoRelatedSym + { private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)9); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 9; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } - - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } - - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } - - inline NoRelatedSym &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; - - return *this; - } - - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } - -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } - -#endif - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { - return 48; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoRelatedSym &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT { - return 38; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderQtyEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT { - return 4294967295; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoRelatedSym &orderQty(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT { return 54; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD RFQSide::Value side() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint8_t)); - return RFQSide::get((val)); - } - - NoRelatedSym &side(const RFQSide::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoRelatedSym writer) { - builder << '{'; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); - - builder << ", "; - builder << R"("Side": )"; - builder << '"' << writer.side() << '"'; - - builder << '}'; - - return builder; - } - - void skip() {} - - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } - - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - size_t length = sbeBlockLength(); - - return length; -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - } - }; - - private: - NoRelatedSym m_noRelatedSym; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoRelatedSymId() SBE_NOEXCEPT { - return 146; - } - - SBE_NODISCARD inline NoRelatedSym &noRelatedSym() { - m_noRelatedSym.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noRelatedSym; - } - - NoRelatedSym &noRelatedSymCount(const std::uint8_t count) { - m_noRelatedSym.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noRelatedSym; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noRelatedSymSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noRelatedSymInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noRelatedSymSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, RequestForQuote543 _writer) { - RequestForQuote543 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "RequestForQuote543", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("QuoteReqID": )"; - builder << +writer.quoteReqID(); - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("QuoteType": )"; - builder << '"' << writer.quoteType() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoRelatedSym": [)"; - writer.noRelatedSym().forEach([&](NoRelatedSym &noRelatedSym) { - if (atLeastOne) { - builder << ", "; + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - atLeastOne = true; - builder << noRelatedSym; - }); - builder << ']'; - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(9)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 9; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - return builder; - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 9; + } - void skip() { - noRelatedSym().forEach([](NoRelatedSym e) { e.skip(); }); - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t NoRelatedSymLength = 0) { + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoRelatedSym &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= securityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoRelatedSym &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderQtyId() SBE_NOEXCEPT + { + return 38; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool orderQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderQtyEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR std::uint32_t orderQtyNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t orderQty() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoRelatedSym &orderQty(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sideId() SBE_NOEXCEPT + { + return 54; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sideInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= sideSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t sideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD RFQSide::Value side() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint8_t)); + return RFQSide::get((val)); + } + + NoRelatedSym &side(const RFQSide::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoRelatedSym writer) + { + builder << '{'; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("Side": )"; + builder << '"' << writer.side() << '"'; + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoRelatedSym::sbeHeaderSize(); - if (NoRelatedSymLength > 254) { - throw std::runtime_error( - "NoRelatedSymLength outside of allowed range [E110]"); - } - length += NoRelatedSymLength * NoRelatedSym::sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } + } + }; + +private: + NoRelatedSym m_noRelatedSym; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoRelatedSymId() SBE_NOEXCEPT + { + return 146; + } + + SBE_NODISCARD inline NoRelatedSym &noRelatedSym() + { + m_noRelatedSym.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRelatedSym; + } + + NoRelatedSym &noRelatedSymCount(const std::uint8_t count) + { + m_noRelatedSym.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRelatedSym; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noRelatedSymSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noRelatedSymInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noRelatedSymSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, RequestForQuote543 _writer) +{ + RequestForQuote543 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "RequestForQuote543", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("QuoteReqID": )"; + builder << +writer.quoteReqID(); + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("QuoteType": )"; + builder << '"' << writer.quoteType() << '"'; + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoRelatedSym": [)"; + writer.noRelatedSym().forEach( + [&](NoRelatedSym &noRelatedSym) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noRelatedSym; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noRelatedSymGroup { noRelatedSym() }; + while (noRelatedSymGroup.hasNext()) + { + noRelatedSymGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noRelatedSymLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoRelatedSym::sbeHeaderSize(); + if (noRelatedSymLength > 254LL) + { + throw std::runtime_error("noRelatedSymLength outside of allowed range [E110]"); + } + length += noRelatedSymLength *NoRelatedSym::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/RequestForQuoteAck546.h b/src/lib/orderman/ilink3/generated/RequestForQuoteAck546.h index e6b724516..0d7fa133f 100644 --- a/src/lib/orderman/ilink3/generated/RequestForQuoteAck546.h +++ b/src/lib/orderman/ilink3/generated/RequestForQuoteAck546.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,1927 +86,2110 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class RequestForQuoteAck546 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class RequestForQuoteAck546 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(358); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(546); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - RequestForQuoteAck546() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - RequestForQuoteAck546( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - RequestForQuoteAck546(char *buffer, const std::uint64_t bufferLength) - : RequestForQuoteAck546( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + RequestForQuoteAck546() = default; - RequestForQuoteAck546( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : RequestForQuoteAck546( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + RequestForQuoteAck546( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)358; - } + RequestForQuoteAck546(char *buffer, const std::uint64_t bufferLength) : + RequestForQuoteAck546(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + RequestForQuoteAck546( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + RequestForQuoteAck546(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)546; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(358); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(546); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "b"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - RequestForQuoteAck546 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = RequestForQuoteAck546( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "b"; + } - RequestForQuoteAck546 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + RequestForQuoteAck546 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = RequestForQuoteAck546(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = RequestForQuoteAck546( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + RequestForQuoteAck546 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - RequestForQuoteAck546 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = RequestForQuoteAck546( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = RequestForQuoteAck546( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + RequestForQuoteAck546 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = RequestForQuoteAck546(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + RequestForQuoteAck546 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - RequestForQuoteAck546 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + RequestForQuoteAck546 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= seqNumSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - RequestForQuoteAck546 &seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } + RequestForQuoteAck546 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RequestForQuoteAck546 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } + RequestForQuoteAck546 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } + static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT + { + return 58; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= textSinceVersion(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 256; + } - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 256; + } - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - RequestForQuoteAck546 &text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } + RequestForQuoteAck546 &text(const std::uint64_t index, const char value) + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } + std::uint64_t getText(char *const dst, const std::uint64_t length) const + { + if (length > 256) + { + throw std::runtime_error("length too large for getText [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - RequestForQuoteAck546 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } + RequestForQuoteAck546 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); + return *this; + } - SBE_NODISCARD std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); + std::string getTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTextAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - RequestForQuoteAck546 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + #if __cplusplus >= 201703L + RequestForQuoteAck546 &putText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#else - RequestForQuoteAck546 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } + return *this; + } + #else + RequestForQuoteAck546 &putText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= senderIDSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 268; + } - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); + return (val); + } - RequestForQuoteAck546 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } + RequestForQuoteAck546 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast(length)); + return length; + } - RequestForQuoteAck546 &putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 20); - return *this; - } + RequestForQuoteAck546 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - RequestForQuoteAck546 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + #if __cplusplus >= 201703L + RequestForQuoteAck546 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#else - RequestForQuoteAck546 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } + return *this; + } + #else + RequestForQuoteAck546 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *ExchangeQuoteReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ExchangeQuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t exchangeQuoteReqIDId() SBE_NOEXCEPT { - return 9770; - } + static SBE_CONSTEXPR std::uint16_t exchangeQuoteReqIDId() SBE_NOEXCEPT + { + return 9770; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - exchangeQuoteReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t exchangeQuoteReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool exchangeQuoteReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool exchangeQuoteReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= exchangeQuoteReqIDSinceVersion(); + return m_actingVersion >= exchangeQuoteReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - exchangeQuoteReqIDEncodingOffset() SBE_NOEXCEPT { - return 288; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t exchangeQuoteReqIDEncodingOffset() SBE_NOEXCEPT + { + return 288; + } - static SBE_CONSTEXPR char exchangeQuoteReqIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char exchangeQuoteReqIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char exchangeQuoteReqIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char exchangeQuoteReqIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char exchangeQuoteReqIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char exchangeQuoteReqIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - exchangeQuoteReqIDEncodingLength() SBE_NOEXCEPT { - return 17; - } + static SBE_CONSTEXPR std::size_t exchangeQuoteReqIDEncodingLength() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint64_t exchangeQuoteReqIDLength() SBE_NOEXCEPT { - return 17; - } + static SBE_CONSTEXPR std::uint64_t exchangeQuoteReqIDLength() SBE_NOEXCEPT + { + return 17; + } - SBE_NODISCARD const char *exchangeQuoteReqID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 288; - } + SBE_NODISCARD const char *exchangeQuoteReqID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 288; + } - SBE_NODISCARD char *exchangeQuoteReqID() SBE_NOEXCEPT { - return m_buffer + m_offset + 288; - } + SBE_NODISCARD char *exchangeQuoteReqID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 288; + } - SBE_NODISCARD char exchangeQuoteReqID(const std::uint64_t index) const { - if (index >= 17) { - throw std::runtime_error( - "index out of range for exchangeQuoteReqID [E104]"); - } + SBE_NODISCARD char exchangeQuoteReqID(const std::uint64_t index) const + { + if (index >= 17) + { + throw std::runtime_error("index out of range for exchangeQuoteReqID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 288 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 288 + (index * 1), sizeof(char)); + return (val); + } - RequestForQuoteAck546 & - exchangeQuoteReqID(const std::uint64_t index, const char value) { - if (index >= 17) { - throw std::runtime_error( - "index out of range for exchangeQuoteReqID [E105]"); - } + RequestForQuoteAck546 &exchangeQuoteReqID(const std::uint64_t index, const char value) + { + if (index >= 17) + { + throw std::runtime_error("index out of range for exchangeQuoteReqID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 288 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 288 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getExchangeQuoteReqID(char *const dst, const std::uint64_t length) const { - if (length > 17) { - throw std::runtime_error( - "length too large for getExchangeQuoteReqID [E106]"); - } + std::uint64_t getExchangeQuoteReqID(char *const dst, const std::uint64_t length) const + { + if (length > 17) + { + throw std::runtime_error("length too large for getExchangeQuoteReqID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 288, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 288, sizeof(char) * static_cast(length)); + return length; + } - RequestForQuoteAck546 & - putExchangeQuoteReqID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 288, src, sizeof(char) * 17); - return *this; - } + RequestForQuoteAck546 &putExchangeQuoteReqID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 288, src, sizeof(char) * 17); + return *this; + } - SBE_NODISCARD std::string getExchangeQuoteReqIDAsString() const { - const char *buffer = m_buffer + m_offset + 288; - size_t length = 0; + SBE_NODISCARD std::string getExchangeQuoteReqIDAsString() const + { + const char *buffer = m_buffer + m_offset + 288; + std::size_t length = 0; - for (; length < 17 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 17 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getExchangeQuoteReqIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getExchangeQuoteReqIDAsString(); + std::string getExchangeQuoteReqIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getExchangeQuoteReqIDAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getExchangeQuoteReqIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 288; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getExchangeQuoteReqIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 288; + std::size_t length = 0; - for (; length < 17 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 17 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - RequestForQuoteAck546 &putExchangeQuoteReqID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 17) { - throw std::runtime_error( - "string too large for putExchangeQuoteReqID [E106]"); - } + #if __cplusplus >= 201703L + RequestForQuoteAck546 &putExchangeQuoteReqID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 17) + { + throw std::runtime_error("string too large for putExchangeQuoteReqID [E106]"); + } - std::memcpy(m_buffer + m_offset + 288, str.data(), srcLength); - for (size_t start = srcLength; start < 17; ++start) { - m_buffer[m_offset + 288 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 288, str.data(), srcLength); + for (std::size_t start = srcLength; start < 17; ++start) + { + m_buffer[m_offset + 288 + start] = 0; + } - return *this; - } -#else - RequestForQuoteAck546 &putExchangeQuoteReqID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 17) { - throw std::runtime_error( - "string too large for putExchangeQuoteReqID [E106]"); - } + return *this; + } + #else + RequestForQuoteAck546 &putExchangeQuoteReqID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 17) + { + throw std::runtime_error("string too large for putExchangeQuoteReqID [E106]"); + } - std::memcpy(m_buffer + m_offset + 288, str.c_str(), srcLength); - for (size_t start = srcLength; start < 17; ++start) { - m_buffer[m_offset + 288 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 288, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 17; ++start) + { + m_buffer[m_offset + 288 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 305; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 305; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 305, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 305, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RequestForQuoteAck546 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 305, &val, sizeof(std::uint64_t)); - return *this; - } + RequestForQuoteAck546 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 305, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - RequestTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimeId() SBE_NOEXCEPT { - return 5979; - } + static SBE_CONSTEXPR std::uint16_t requestTimeId() SBE_NOEXCEPT + { + return 5979; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimeSinceVersion(); + return m_actingVersion >= requestTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimeEncodingOffset() SBE_NOEXCEPT { - return 313; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimeEncodingOffset() SBE_NOEXCEPT + { + return 313; + } - static SBE_CONSTEXPR std::uint64_t requestTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 313, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 313, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RequestForQuoteAck546 &requestTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 313, &val, sizeof(std::uint64_t)); - return *this; - } + RequestForQuoteAck546 &requestTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 313, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); + return m_actingVersion >= sendingTimeEpochSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 321; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 321; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 321, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 321, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RequestForQuoteAck546 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 321, &val, sizeof(std::uint64_t)); - return *this; - } + RequestForQuoteAck546 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 321, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteReqIDId() SBE_NOEXCEPT { - return 131; - } + static SBE_CONSTEXPR std::uint16_t quoteReqIDId() SBE_NOEXCEPT + { + return 131; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteReqIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteReqIDSinceVersion(); + return m_actingVersion >= quoteReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteReqIDEncodingOffset() SBE_NOEXCEPT { - return 329; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteReqIDEncodingOffset() SBE_NOEXCEPT + { + return 329; + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t quoteReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t quoteReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 329, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RequestForQuoteAck546 "eReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 329, &val, sizeof(std::uint64_t)); - return *this; - } + RequestForQuoteAck546 "eReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 329, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= locationSinceVersion(); + return m_actingVersion >= locationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 337; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 337; + } - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 337; - } + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 337; + } - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 337; - } + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 337; + } - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 337 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 337 + (index * 1), sizeof(char)); + return (val); + } - RequestForQuoteAck546 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } + RequestForQuoteAck546 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 337 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 337 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 337, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 337, sizeof(char) * static_cast(length)); + return length; + } - RequestForQuoteAck546 &putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 337, src, sizeof(char) * 5); - return *this; - } + RequestForQuoteAck546 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 337, src, sizeof(char) * 5); + return *this; + } - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 337; - size_t length = 0; + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 337; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 337; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 337; + std::size_t length = 0; - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - RequestForQuoteAck546 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + #if __cplusplus >= 201703L + RequestForQuoteAck546 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 337, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 337 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 337, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 337 + start] = 0; + } - return *this; - } -#else - RequestForQuoteAck546 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } + return *this; + } + #else + RequestForQuoteAck546 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } - std::memcpy(m_buffer + m_offset + 337, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 337 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 337, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 337 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *QuoteRejectReasonMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteRejectReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonId() SBE_NOEXCEPT { - return 300; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonId() SBE_NOEXCEPT + { + return 300; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteRejectReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteRejectReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteRejectReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteRejectReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteRejectReasonSinceVersion(); + return m_actingVersion >= quoteRejectReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteRejectReasonEncodingOffset() SBE_NOEXCEPT { - return 342; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteRejectReasonEncodingOffset() SBE_NOEXCEPT + { + return 342; + } - static SBE_CONSTEXPR std::uint16_t - quoteRejectReasonNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t quoteRejectReasonMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - quoteRejectReasonEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t quoteRejectReasonEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t quoteRejectReason() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 342, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t quoteRejectReason() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 342, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - RequestForQuoteAck546 & - quoteRejectReason(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 342, &val, sizeof(std::uint16_t)); - return *this; - } + RequestForQuoteAck546 "eRejectReason(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 342, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayDurationSinceVersion(); + return m_actingVersion >= delayDurationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 344; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 344; + } - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 344, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 344, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - RequestForQuoteAck546 & - delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 344, &val, sizeof(std::uint16_t)); - return *this; - } + RequestForQuoteAck546 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 344, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - QuoteStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *QuoteStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t quoteStatusId() SBE_NOEXCEPT { - return 297; - } + static SBE_CONSTEXPR std::uint16_t quoteStatusId() SBE_NOEXCEPT + { + return 297; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool quoteStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool quoteStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= quoteStatusSinceVersion(); + return m_actingVersion >= quoteStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteStatusEncodingOffset() SBE_NOEXCEPT { - return 346; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteStatusEncodingOffset() SBE_NOEXCEPT + { + return 346; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD QuoteAckStatus::Value quoteStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 346, sizeof(std::uint8_t)); - return QuoteAckStatus::get((val)); - } + SBE_NODISCARD std::uint8_t quoteStatusRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 346, sizeof(std::uint8_t)); + return (val); + } - RequestForQuoteAck546 & - quoteStatus(const QuoteAckStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 346, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD QuoteAckStatus::Value quoteStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 346, sizeof(std::uint8_t)); + return QuoteAckStatus::get((val)); + } - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + RequestForQuoteAck546 "eStatus(const QuoteAckStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 346, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); + return m_actingVersion >= manualOrderIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 347; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 347; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 347, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 347, sizeof(std::uint8_t)); + return (val); + } - RequestForQuoteAck546 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 347, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 347, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + RequestForQuoteAck546 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 347, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 348; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 348; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint8_t)); + return (val); + } - RequestForQuoteAck546 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 348, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + RequestForQuoteAck546 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 348, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= possRetransFlagSinceVersion(); + return m_actingVersion >= possRetransFlagSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 349; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 349; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - if (m_actingVersion < 2) { - return BooleanFlag::NULL_VALUE; - } + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + if (m_actingVersion < 2) + { + return static_cast(255); + } - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 349, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 349, sizeof(std::uint8_t)); + return (val); + } - RequestForQuoteAck546 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 349, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + if (m_actingVersion < 2) + { + return BooleanFlag::NULL_VALUE; + } - SBE_NODISCARD static const char * - DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 349, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } - static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT { - return 7552; - } + RequestForQuoteAck546 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 349, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayToTimeSinceVersion() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static const char *DelayToTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT { + static SBE_CONSTEXPR std::uint16_t delayToTimeId() SBE_NOEXCEPT + { + return 7552; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayToTimeSinceVersion() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD bool delayToTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= delayToTimeSinceVersion(); + return m_actingVersion >= delayToTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayToTimeEncodingOffset() SBE_NOEXCEPT { - return 350; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayToTimeEncodingOffset() SBE_NOEXCEPT + { + return 350; + } - static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t delayToTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t delayToTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT { - if (m_actingVersion < 4) { - return 0xffffffffffffffffL; - } + SBE_NODISCARD std::uint64_t delayToTime() const SBE_NOEXCEPT + { + if (m_actingVersion < 4) + { + return UINT64_C(0xffffffffffffffff); + } - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 350, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 350, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RequestForQuoteAck546 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 350, &val, sizeof(std::uint64_t)); - return *this; - } + RequestForQuoteAck546 &delayToTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 350, &val, sizeof(std::uint64_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - RequestForQuoteAck546 _writer) { - RequestForQuoteAck546 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "RequestForQuoteAck546", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, RequestForQuoteAck546 _writer) +{ + RequestForQuoteAck546 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + builder << '{'; + builder << R"("Name": "RequestForQuoteAck546", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ExchangeQuoteReqID": )"; - builder << '"' - << writer.getExchangeQuoteReqIDAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + builder << ", "; + builder << R"("ExchangeQuoteReqID": )"; + builder << '"' << + writer.getExchangeQuoteReqIDAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("RequestTime": )"; - builder << +writer.requestTime(); + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); + builder << ", "; + builder << R"("RequestTime": )"; + builder << +writer.requestTime(); - builder << ", "; - builder << R"("QuoteReqID": )"; - builder << +writer.quoteReqID(); + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("QuoteReqID": )"; + builder << +writer.quoteReqID(); - builder << ", "; - builder << R"("QuoteRejectReason": )"; - builder << +writer.quoteRejectReason(); + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); + builder << ", "; + builder << R"("QuoteRejectReason": )"; + builder << +writer.quoteRejectReason(); - builder << ", "; - builder << R"("QuoteStatus": )"; - builder << '"' << writer.quoteStatus() << '"'; + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; + builder << ", "; + builder << R"("QuoteStatus": )"; + builder << '"' << writer.quoteStatus() << '"'; - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - builder << ", "; - builder << R"("DelayToTime": )"; - builder << +writer.delayToTime(); + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; - builder << '}'; + builder << ", "; + builder << R"("DelayToTime": )"; + builder << +writer.delayToTime(); - return builder; - } + builder << '}'; - void skip() {} + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } +void skip() +{ +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/Retransmission509.h b/src/lib/orderman/ilink3/generated/Retransmission509.h index 00f482746..aca45553b 100644 --- a/src/lib/orderman/ilink3/generated/Retransmission509.h +++ b/src/lib/orderman/ilink3/generated/Retransmission509.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,656 +86,750 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class Retransmission509 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class Retransmission509 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(31); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(509); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - Retransmission509() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - Retransmission509( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - Retransmission509(char *buffer, const std::uint64_t bufferLength) - : Retransmission509( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + Retransmission509() = default; - Retransmission509( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : Retransmission509( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + Retransmission509( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)31; - } + Retransmission509(char *buffer, const std::uint64_t bufferLength) : + Retransmission509(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + Retransmission509( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + Retransmission509(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)509; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(31); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(509); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "Retransmission"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - Retransmission509 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = Retransmission509( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "Retransmission"; + } - Retransmission509 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + Retransmission509 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = Retransmission509(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = Retransmission509( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + Retransmission509 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - Retransmission509 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = Retransmission509( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = Retransmission509( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + Retransmission509 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = Retransmission509(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + Retransmission509 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - Retransmission509 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + Retransmission509 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Retransmission509 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + Retransmission509 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LastUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUUIDId() SBE_NOEXCEPT { - return 39017; - } + static SBE_CONSTEXPR std::uint16_t lastUUIDId() SBE_NOEXCEPT + { + return 39017; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUUIDSinceVersion(); + return m_actingVersion >= lastUUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUUIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUUIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t lastUUIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t lastUUIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t lastUUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t lastUUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t lastUUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Retransmission509 &lastUUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + Retransmission509 &lastUUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Retransmission509 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint64_t)); - return *this; - } + Retransmission509 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - FromSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FromSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fromSeqNoId() SBE_NOEXCEPT { - return 39018; - } + static SBE_CONSTEXPR std::uint16_t fromSeqNoId() SBE_NOEXCEPT + { + return 39018; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fromSeqNoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fromSeqNoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fromSeqNoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool fromSeqNoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fromSeqNoSinceVersion(); + return m_actingVersion >= fromSeqNoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fromSeqNoEncodingOffset() SBE_NOEXCEPT { - return 24; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fromSeqNoEncodingOffset() SBE_NOEXCEPT + { + return 24; + } - static SBE_CONSTEXPR std::uint32_t fromSeqNoNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t fromSeqNoNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t fromSeqNoMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t fromSeqNoMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t fromSeqNoMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t fromSeqNoMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t fromSeqNoEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t fromSeqNoEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t fromSeqNo() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t fromSeqNo() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - Retransmission509 &fromSeqNo(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); - return *this; - } + Retransmission509 &fromSeqNo(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MsgCountMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MsgCountMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t msgCountId() SBE_NOEXCEPT { - return 39019; - } + static SBE_CONSTEXPR std::uint16_t msgCountId() SBE_NOEXCEPT + { + return 39019; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - msgCountSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t msgCountSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool msgCountInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool msgCountInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= msgCountSinceVersion(); + return m_actingVersion >= msgCountSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - msgCountEncodingOffset() SBE_NOEXCEPT { - return 28; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t msgCountEncodingOffset() SBE_NOEXCEPT + { + return 28; + } - static SBE_CONSTEXPR std::uint16_t msgCountNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t msgCountNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t msgCountMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t msgCountMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t msgCountMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t msgCountMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t msgCountEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t msgCountEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t msgCount() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t msgCount() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - Retransmission509 &msgCount(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint16_t)); - return *this; - } + Retransmission509 &msgCount(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 30; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 30; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 30, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 30, sizeof(std::uint8_t)); + return (val); + } - Retransmission509 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 30, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 30, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, Retransmission509 _writer) { - Retransmission509 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "Retransmission509", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + Retransmission509 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 30, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("UUID": )"; - builder << +writer.uUID(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, Retransmission509 _writer) +{ + Retransmission509 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("LastUUID": )"; - builder << +writer.lastUUID(); + builder << '{'; + builder << R"("Name": "Retransmission509", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("FromSeqNo": )"; - builder << +writer.fromSeqNo(); + builder << ", "; + builder << R"("LastUUID": )"; + builder << +writer.lastUUID(); - builder << ", "; - builder << R"("MsgCount": )"; - builder << +writer.msgCount(); + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("FromSeqNo": )"; + builder << +writer.fromSeqNo(); - builder << '}'; + builder << ", "; + builder << R"("MsgCount": )"; + builder << +writer.msgCount(); - return builder; - } + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - void skip() {} + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/RetransmitReject510.h b/src/lib/orderman/ilink3/generated/RetransmitReject510.h index d9fe5004d..177a97d37 100644 --- a/src/lib/orderman/ilink3/generated/RetransmitReject510.h +++ b/src/lib/orderman/ilink3/generated/RetransmitReject510.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,777 +86,886 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class RetransmitReject510 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class RetransmitReject510 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(75); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(510); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - RetransmitReject510() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - RetransmitReject510( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - RetransmitReject510(char *buffer, const std::uint64_t bufferLength) - : RetransmitReject510( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + RetransmitReject510() = default; - RetransmitReject510( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : RetransmitReject510( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + RetransmitReject510( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)75; - } + RetransmitReject510(char *buffer, const std::uint64_t bufferLength) : + RetransmitReject510(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + RetransmitReject510( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + RetransmitReject510(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)510; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(75); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(510); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "RetransmitReject"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - RetransmitReject510 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = RetransmitReject510( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "RetransmitReject"; + } - RetransmitReject510 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + RetransmitReject510 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = RetransmitReject510(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = RetransmitReject510( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + RetransmitReject510 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - RetransmitReject510 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = RetransmitReject510( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = RetransmitReject510( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + RetransmitReject510 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = RetransmitReject510(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + RetransmitReject510 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - RetransmitReject510 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + RetransmitReject510 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t reasonId() SBE_NOEXCEPT { return 39011; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - reasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool reasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t reasonId() SBE_NOEXCEPT + { + return 39011; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool reasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= reasonSinceVersion(); + return m_actingVersion >= reasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - reasonEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reasonEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT { - return 48; - } + static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t reasonLength() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint64_t reasonLength() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD const char *reason() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } + SBE_NODISCARD const char *reason() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char *reason() SBE_NOEXCEPT { return m_buffer + m_offset + 0; } + SBE_NODISCARD char *reason() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char reason(const std::uint64_t index) const { - if (index >= 48) { - throw std::runtime_error("index out of range for reason [E104]"); - } + SBE_NODISCARD char reason(const std::uint64_t index) const + { + if (index >= 48) + { + throw std::runtime_error("index out of range for reason [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - RetransmitReject510 &reason(const std::uint64_t index, const char value) { - if (index >= 48) { - throw std::runtime_error("index out of range for reason [E105]"); - } + RetransmitReject510 &reason(const std::uint64_t index, const char value) + { + if (index >= 48) + { + throw std::runtime_error("index out of range for reason [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getReason(char *const dst, const std::uint64_t length) const { - if (length > 48) { - throw std::runtime_error("length too large for getReason [E106]"); - } + std::uint64_t getReason(char *const dst, const std::uint64_t length) const + { + if (length > 48) + { + throw std::runtime_error("length too large for getReason [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - RetransmitReject510 &putReason(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 48); - return *this; - } + RetransmitReject510 &putReason(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 48); + return *this; + } - SBE_NODISCARD std::string getReasonAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + SBE_NODISCARD std::string getReasonAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 48 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 48 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getReasonAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getReasonAsString(); + std::string getReasonAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getReasonAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 48 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 48 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - RetransmitReject510 &putReason(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 48) { - throw std::runtime_error("string too large for putReason [E106]"); - } + #if __cplusplus >= 201703L + RetransmitReject510 &putReason(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 48) + { + throw std::runtime_error("string too large for putReason [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 48; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 48; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#else - RetransmitReject510 &putReason(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 48) { - throw std::runtime_error("string too large for putReason [E106]"); - } + return *this; + } + #else + RetransmitReject510 &putReason(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 48) + { + throw std::runtime_error("string too large for putReason [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 48; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 48; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 48; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RetransmitReject510 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); - return *this; - } + RetransmitReject510 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LastUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUUIDId() SBE_NOEXCEPT { - return 39017; - } + static SBE_CONSTEXPR std::uint16_t lastUUIDId() SBE_NOEXCEPT + { + return 39017; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUUIDSinceVersion(); + return m_actingVersion >= lastUUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUUIDEncodingOffset() SBE_NOEXCEPT { - return 56; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUUIDEncodingOffset() SBE_NOEXCEPT + { + return 56; + } - static SBE_CONSTEXPR std::uint64_t lastUUIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t lastUUIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t lastUUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t lastUUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t lastUUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RetransmitReject510 &lastUUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); - return *this; - } + RetransmitReject510 &lastUUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 64; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RetransmitReject510 & - requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint64_t)); - return *this; - } + RetransmitReject510 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t errorCodesId() SBE_NOEXCEPT { - return 39012; - } + static SBE_CONSTEXPR std::uint16_t errorCodesId() SBE_NOEXCEPT + { + return 39012; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - errorCodesSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t errorCodesSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool errorCodesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool errorCodesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= errorCodesSinceVersion(); + return m_actingVersion >= errorCodesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - errorCodesEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t errorCodesEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - static SBE_CONSTEXPR std::uint16_t errorCodesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t errorCodesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t errorCodes() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 72, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t errorCodes() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 72, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - RetransmitReject510 &errorCodes(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 72, &val, sizeof(std::uint16_t)); - return *this; - } + RetransmitReject510 &errorCodes(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 72, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 74; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 74; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 74, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 74, sizeof(std::uint8_t)); + return (val); + } - RetransmitReject510 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 74, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 74, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - RetransmitReject510 _writer) { - RetransmitReject510 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "RetransmitReject510", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + RetransmitReject510 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 74, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("Reason": )"; - builder << '"' << writer.getReasonAsJsonEscapedString().c_str() << '"'; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, RetransmitReject510 _writer) +{ + RetransmitReject510 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << '{'; + builder << R"("Name": "RetransmitReject510", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("LastUUID": )"; - builder << +writer.lastUUID(); + builder << R"("Reason": )"; + builder << '"' << + writer.getReasonAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("ErrorCodes": )"; - builder << +writer.errorCodes(); + builder << ", "; + builder << R"("LastUUID": )"; + builder << +writer.lastUUID(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << '}'; + builder << ", "; + builder << R"("ErrorCodes": )"; + builder << +writer.errorCodes(); - return builder; - } + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - void skip() {} + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/RetransmitRequest508.h b/src/lib/orderman/ilink3/generated/RetransmitRequest508.h index fcb85eb60..34b5fae83 100644 --- a/src/lib/orderman/ilink3/generated/RetransmitRequest508.h +++ b/src/lib/orderman/ilink3/generated/RetransmitRequest508.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,602 +86,683 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class RetransmitRequest508 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class RetransmitRequest508 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(30); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(508); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - RetransmitRequest508() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - RetransmitRequest508( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - RetransmitRequest508(char *buffer, const std::uint64_t bufferLength) - : RetransmitRequest508( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + RetransmitRequest508() = default; - RetransmitRequest508( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : RetransmitRequest508( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + RetransmitRequest508( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)30; - } + RetransmitRequest508(char *buffer, const std::uint64_t bufferLength) : + RetransmitRequest508(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + RetransmitRequest508( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + RetransmitRequest508(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)508; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(30); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(508); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "RetransmitRequest"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - RetransmitRequest508 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = RetransmitRequest508( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "RetransmitRequest"; + } - RetransmitRequest508 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + RetransmitRequest508 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = RetransmitRequest508(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = RetransmitRequest508( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + RetransmitRequest508 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - RetransmitRequest508 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = RetransmitRequest508( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = RetransmitRequest508( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + RetransmitRequest508 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = RetransmitRequest508(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + RetransmitRequest508 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - RetransmitRequest508 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + RetransmitRequest508 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RetransmitRequest508 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + RetransmitRequest508 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - LastUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUUIDId() SBE_NOEXCEPT { - return 39017; - } + static SBE_CONSTEXPR std::uint16_t lastUUIDId() SBE_NOEXCEPT + { + return 39017; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUUIDSinceVersion(); + return m_actingVersion >= lastUUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUUIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUUIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t lastUUIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } + static SBE_CONSTEXPR std::uint64_t lastUUIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } - static SBE_CONSTEXPR std::uint64_t lastUUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t lastUUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t lastUUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RetransmitRequest508 &lastUUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } + RetransmitRequest508 &lastUUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - RetransmitRequest508 & - requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint64_t)); - return *this; - } + RetransmitRequest508 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - FromSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FromSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t fromSeqNoId() SBE_NOEXCEPT { - return 39018; - } + static SBE_CONSTEXPR std::uint16_t fromSeqNoId() SBE_NOEXCEPT + { + return 39018; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - fromSeqNoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t fromSeqNoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool fromSeqNoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool fromSeqNoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= fromSeqNoSinceVersion(); + return m_actingVersion >= fromSeqNoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - fromSeqNoEncodingOffset() SBE_NOEXCEPT { - return 24; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t fromSeqNoEncodingOffset() SBE_NOEXCEPT + { + return 24; + } - static SBE_CONSTEXPR std::uint32_t fromSeqNoNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t fromSeqNoNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t fromSeqNoMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t fromSeqNoMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t fromSeqNoMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t fromSeqNoMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t fromSeqNoEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t fromSeqNoEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t fromSeqNo() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t fromSeqNo() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - RetransmitRequest508 &fromSeqNo(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); - return *this; - } + RetransmitRequest508 &fromSeqNo(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MsgCountMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MsgCountMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t msgCountId() SBE_NOEXCEPT { - return 39019; - } + static SBE_CONSTEXPR std::uint16_t msgCountId() SBE_NOEXCEPT + { + return 39019; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - msgCountSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t msgCountSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool msgCountInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool msgCountInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= msgCountSinceVersion(); + return m_actingVersion >= msgCountSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - msgCountEncodingOffset() SBE_NOEXCEPT { - return 28; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t msgCountEncodingOffset() SBE_NOEXCEPT + { + return 28; + } - static SBE_CONSTEXPR std::uint16_t msgCountNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t msgCountNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t msgCountMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t msgCountMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t msgCountMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t msgCountMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t msgCountEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t msgCountEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t msgCount() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t msgCount() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - RetransmitRequest508 &msgCount(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint16_t)); - return *this; - } + RetransmitRequest508 &msgCount(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint16_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - RetransmitRequest508 _writer) { - RetransmitRequest508 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "RetransmitRequest508", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, RetransmitRequest508 _writer) +{ + RetransmitRequest508 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << '{'; + builder << R"("Name": "RetransmitRequest508", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("LastUUID": )"; - builder << +writer.lastUUID(); + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << ", "; + builder << R"("LastUUID": )"; + builder << +writer.lastUUID(); - builder << ", "; - builder << R"("FromSeqNo": )"; - builder << +writer.fromSeqNo(); + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << ", "; - builder << R"("MsgCount": )"; - builder << +writer.msgCount(); + builder << ", "; + builder << R"("FromSeqNo": )"; + builder << +writer.fromSeqNo(); - builder << '}'; + builder << ", "; + builder << R"("MsgCount": )"; + builder << +writer.msgCount(); - return builder; - } + builder << '}'; - void skip() {} + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } +void skip() +{ +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/SLEDS.h b/src/lib/orderman/ilink3/generated/SLEDS.h index 64bea78b6..750e9aefe 100644 --- a/src/lib/orderman/ilink3/generated/SLEDS.h +++ b/src/lib/orderman/ilink3/generated/SLEDS.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_SLEDS_H_ #define _ILINKBINARY_SLEDS_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class SLEDS { - public: - enum Value { - TradeClearingatExecutionPrice = (std::uint8_t)0, - TradeClearingatAlternateClearingPrice = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class SLEDS +{ +public: + enum Value + { + TradeClearingatExecutionPrice = static_cast(0), + TradeClearingatAlternateClearingPrice = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static SLEDS::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return TradeClearingatExecutionPrice; - case 1: - return TradeClearingatAlternateClearingPrice; - case 255: - return NULL_VALUE; - } + static SLEDS::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return TradeClearingatExecutionPrice; + case static_cast(1): return TradeClearingatAlternateClearingPrice; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum SLEDS [E103]"); - } + throw std::runtime_error("unknown value for enum SLEDS [E103]"); + } - static const char *c_str(const SLEDS::Value value) { - switch (value) { - case TradeClearingatExecutionPrice: - return "TradeClearingatExecutionPrice"; - case TradeClearingatAlternateClearingPrice: - return "TradeClearingatAlternateClearingPrice"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SLEDS::Value value) + { + switch (value) + { + case TradeClearingatExecutionPrice: return "TradeClearingatExecutionPrice"; + case TradeClearingatAlternateClearingPrice: return "TradeClearingatAlternateClearingPrice"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum SLEDS [E103]:"); - } + throw std::runtime_error("unknown value for enum SLEDS [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, SLEDS::Value m) { - return os << SLEDS::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, SLEDS::Value m) + { + return os << SLEDS::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/SMPI.h b/src/lib/orderman/ilink3/generated/SMPI.h index 4c117dd64..2698520ef 100644 --- a/src/lib/orderman/ilink3/generated/SMPI.h +++ b/src/lib/orderman/ilink3/generated/SMPI.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_SMPI_H_ #define _ILINKBINARY_SMPI_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class SMPI { - public: - enum Value { - CancelNewest = (char)78, - CancelOldest = (char)79, - NULL_VALUE = (char)0 - }; +class SMPI +{ +public: + enum Value + { + CancelNewest = static_cast(78), + CancelOldest = static_cast(79), + NULL_VALUE = static_cast(0x00) + }; - static SMPI::Value get(const char value) { - switch (value) { - case 78: - return CancelNewest; - case 79: - return CancelOldest; - case 0: - return NULL_VALUE; - } + static SMPI::Value get(const char value) + { + switch (value) + { + case static_cast(78): return CancelNewest; + case static_cast(79): return CancelOldest; + case static_cast(0x00): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum SMPI [E103]"); - } + throw std::runtime_error("unknown value for enum SMPI [E103]"); + } - static const char *c_str(const SMPI::Value value) { - switch (value) { - case CancelNewest: - return "CancelNewest"; - case CancelOldest: - return "CancelOldest"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SMPI::Value value) + { + switch (value) + { + case CancelNewest: return "CancelNewest"; + case CancelOldest: return "CancelOldest"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum SMPI [E103]:"); - } + throw std::runtime_error("unknown value for enum SMPI [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, SMPI::Value m) { - return os << SMPI::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, SMPI::Value m) + { + return os << SMPI::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/SecRspTyp.h b/src/lib/orderman/ilink3/generated/SecRspTyp.h index 79cb24028..64613e601 100644 --- a/src/lib/orderman/ilink3/generated/SecRspTyp.h +++ b/src/lib/orderman/ilink3/generated/SecRspTyp.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_SECRSPTYP_H_ #define _ILINKBINARY_SECRSPTYP_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,53 +25,51 @@ namespace iLinkBinary { -class SecRspTyp { - public: - enum Value { - AcceptSecurityProposalasis = (std::uint8_t)1, - AcceptSecurityproposalwithrevisionsasindicatedinthemessage = - (std::uint8_t)2, - RejectSecurityProposal = (std::uint8_t)5, - NULL_VALUE = (std::uint8_t)255 - }; +class SecRspTyp +{ +public: + enum Value + { + AcceptSecurityProposalasis = static_cast(1), + AcceptSecurityproposalwithrevisionsasindicatedinthemessage = static_cast(2), + RejectSecurityProposal = static_cast(5), + NULL_VALUE = static_cast(255) + }; - static SecRspTyp::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return AcceptSecurityProposalasis; - case 2: - return AcceptSecurityproposalwithrevisionsasindicatedinthemessage; - case 5: - return RejectSecurityProposal; - case 255: - return NULL_VALUE; - } + static SecRspTyp::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return AcceptSecurityProposalasis; + case static_cast(2): return AcceptSecurityproposalwithrevisionsasindicatedinthemessage; + case static_cast(5): return RejectSecurityProposal; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum SecRspTyp [E103]"); - } + throw std::runtime_error("unknown value for enum SecRspTyp [E103]"); + } - static const char *c_str(const SecRspTyp::Value value) { - switch (value) { - case AcceptSecurityProposalasis: - return "AcceptSecurityProposalasis"; - case AcceptSecurityproposalwithrevisionsasindicatedinthemessage: - return "AcceptSecurityproposalwithrevisionsasindicatedinthemessage"; - case RejectSecurityProposal: - return "RejectSecurityProposal"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SecRspTyp::Value value) + { + switch (value) + { + case AcceptSecurityProposalasis: return "AcceptSecurityProposalasis"; + case AcceptSecurityproposalwithrevisionsasindicatedinthemessage: return "AcceptSecurityproposalwithrevisionsasindicatedinthemessage"; + case RejectSecurityProposal: return "RejectSecurityProposal"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum SecRspTyp [E103]:"); - } + throw std::runtime_error("unknown value for enum SecRspTyp [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, SecRspTyp::Value m) { - return os << SecRspTyp::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, SecRspTyp::Value m) + { + return os << SecRspTyp::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/SecurityDefinitionRequest560.h b/src/lib/orderman/ilink3/generated/SecurityDefinitionRequest560.h index 6a3affada..ea72679cf 100644 --- a/src/lib/orderman/ilink3/generated/SecurityDefinitionRequest560.h +++ b/src/lib/orderman/ilink3/generated/SecurityDefinitionRequest560.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,2277 +86,2897 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class SecurityDefinitionRequest560 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - SecurityDefinitionRequest560() = default; - - SecurityDefinitionRequest560( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - SecurityDefinitionRequest560(char *buffer, const std::uint64_t bufferLength) - : SecurityDefinitionRequest560( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - SecurityDefinitionRequest560( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : SecurityDefinitionRequest560( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)71; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)560; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "c"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - SecurityDefinitionRequest560 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = SecurityDefinitionRequest560( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - SecurityDefinitionRequest560 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = SecurityDefinitionRequest560( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - SecurityDefinitionRequest560 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = SecurityDefinitionRequest560( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD std::uint64_t decodeLength() const { - SecurityDefinitionRequest560 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - SecurityDefinitionRequest560 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecurityReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityReqIDId() SBE_NOEXCEPT { - return 320; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityReqIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t securityReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t securityReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t securityReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t securityReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t securityReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - SecurityDefinitionRequest560 & - securityReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - SecurityDefinitionRequest560 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - SecurityDefinitionRequest560 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 21; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionRequest560 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 21, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionRequest560 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 21; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionRequest560 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionRequest560 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 21 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *SecurityReqTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityReqTypeId() SBE_NOEXCEPT { - return 321; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityReqTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityReqTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityReqTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityReqTypeEncodingOffset() SBE_NOEXCEPT { - return 41; - } - - static SBE_CONSTEXPR char securityReqTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char securityReqTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char securityReqTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - securityReqTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t securityReqTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *securityReqType() const { - static const std::uint8_t securityReqTypeValues[] = {49}; - - return (const char *)securityReqTypeValues; - } - - SBE_NODISCARD char securityReqType(const std::uint64_t index) const { - static const std::uint8_t securityReqTypeValues[] = {49}; - - return (char)securityReqTypeValues[index]; - } - - std::uint64_t - getSecurityReqType(char *dst, const std::uint64_t length) const { - static std::uint8_t securityReqTypeValues[] = {49}; - std::uint64_t bytesToCopy = length < sizeof(securityReqTypeValues) - ? length - : sizeof(securityReqTypeValues); - - std::memcpy(dst, securityReqTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getSecurityReqTypeAsString() const { - static const std::uint8_t SecurityReqTypeValues[] = {49}; - - return std::string((const char *)SecurityReqTypeValues, 1); - } - - std::string getSecurityReqTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityReqTypeAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 41; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - SecurityDefinitionRequest560 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SecuritySubTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securitySubTypeId() SBE_NOEXCEPT { - return 762; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securitySubTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securitySubTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securitySubTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securitySubTypeEncodingOffset() SBE_NOEXCEPT { - return 49; - } - - static SBE_CONSTEXPR char securitySubTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char securitySubTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char securitySubTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - securitySubTypeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t securitySubTypeLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD const char *securitySubType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } - - SBE_NODISCARD char *securitySubType() SBE_NOEXCEPT { - return m_buffer + m_offset + 49; - } - - SBE_NODISCARD char securitySubType(const std::uint64_t index) const { - if (index >= 8) { - throw std::runtime_error( - "index out of range for securitySubType [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionRequest560 & - securitySubType(const std::uint64_t index, const char value) { - if (index >= 8) { - throw std::runtime_error( - "index out of range for securitySubType [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSecuritySubType(char *const dst, const std::uint64_t length) const { - if (length > 8) { - throw std::runtime_error( - "length too large for getSecuritySubType [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 49, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionRequest560 & - putSecuritySubType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 8); - return *this; - } - - SBE_NODISCARD std::string getSecuritySubTypeAsString() const { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; - - for (; length < 8 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSecuritySubTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecuritySubTypeAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getSecuritySubTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 49; - size_t length = 0; - - for (; length < 8 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionRequest560 & - putSecuritySubType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 8) { - throw std::runtime_error( - "string too large for putSecuritySubType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); - for (size_t start = srcLength; start < 8; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionRequest560 &putSecuritySubType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 8) { - throw std::runtime_error( - "string too large for putSecuritySubType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); - for (size_t start = srcLength; start < 8; ++start) { - m_buffer[m_offset + 49 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 57; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 57; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 57; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 57 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionRequest560 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 57 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 57, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionRequest560 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 57, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 57; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 57; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionRequest560 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 57, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 57 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionRequest560 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 57, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 57 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - StartDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t startDateId() SBE_NOEXCEPT { return 916; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - startDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool startDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= startDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - startDateEncodingOffset() SBE_NOEXCEPT { - return 62; - } - - static SBE_CONSTEXPR std::uint16_t startDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t startDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t startDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t startDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t startDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 62, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - SecurityDefinitionRequest560 & - startDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 62, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - EndDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t endDateId() SBE_NOEXCEPT { return 917; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - endDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool endDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= endDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - endDateEncodingOffset() SBE_NOEXCEPT { - return 64; - } - - static SBE_CONSTEXPR std::uint16_t endDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t endDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t endDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t endDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t endDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - SecurityDefinitionRequest560 & - endDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char *MaxNoOfSubstitutionsMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t maxNoOfSubstitutionsId() SBE_NOEXCEPT { - return 37715; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxNoOfSubstitutionsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool maxNoOfSubstitutionsInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= maxNoOfSubstitutionsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxNoOfSubstitutionsEncodingOffset() SBE_NOEXCEPT { - return 66; - } - - static SBE_CONSTEXPR std::uint8_t - maxNoOfSubstitutionsNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } - - static SBE_CONSTEXPR std::uint8_t - maxNoOfSubstitutionsMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - maxNoOfSubstitutionsMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - maxNoOfSubstitutionsEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t maxNoOfSubstitutions() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); - return (val); - } - - SecurityDefinitionRequest560 & - maxNoOfSubstitutions(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - SourceRepoIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sourceRepoIDId() SBE_NOEXCEPT { - return 5677; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sourceRepoIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sourceRepoIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sourceRepoIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sourceRepoIDEncodingOffset() SBE_NOEXCEPT { - return 67; - } - - static SBE_CONSTEXPR std::int32_t sourceRepoIDNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t sourceRepoIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t sourceRepoIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t sourceRepoIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t sourceRepoID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - SecurityDefinitionRequest560 & - sourceRepoID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::int32_t)); - return *this; - } - - class NoLegs { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)19); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 19; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 19; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { +class SecurityDefinitionRequest560 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(72); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(560); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + SecurityDefinitionRequest560() = default; + + SecurityDefinitionRequest560( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + SecurityDefinitionRequest560(char *buffer, const std::uint64_t bufferLength) : + SecurityDefinitionRequest560(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + SecurityDefinitionRequest560( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + SecurityDefinitionRequest560(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(72); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(560); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "c"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + SecurityDefinitionRequest560 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = SecurityDefinitionRequest560(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + SecurityDefinitionRequest560 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = SecurityDefinitionRequest560( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + SecurityDefinitionRequest560 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = SecurityDefinitionRequest560(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + SecurityDefinitionRequest560 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + } + return position; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + SecurityDefinitionRequest560 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoLegs &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - return *this; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } - SBE_NODISCARD static const char *LegSecurityIDSourceMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t legSecurityIDSourceId() SBE_NOEXCEPT { - return 603; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSecurityIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legSecurityIDSourceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legSecurityIDSourceSinceVersion(); + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSecurityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char legSecurityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR char legSecurityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR char legSecurityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - legSecurityIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint64_t - legSecurityIDSourceLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SBE_NODISCARD const char *legSecurityIDSource() const { - static const std::uint8_t legSecurityIDSourceValues[] = {56}; + SecurityDefinitionRequest560 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - return (const char *)legSecurityIDSourceValues; - } + SBE_NODISCARD static const char *SecurityReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD char legSecurityIDSource(const std::uint64_t index) const { - static const std::uint8_t legSecurityIDSourceValues[] = {56}; + static SBE_CONSTEXPR std::uint16_t securityReqIDId() SBE_NOEXCEPT + { + return 320; + } - return (char)legSecurityIDSourceValues[index]; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - std::uint64_t - getLegSecurityIDSource(char *dst, const std::uint64_t length) const { - static std::uint8_t legSecurityIDSourceValues[] = {56}; - std::uint64_t bytesToCopy = length < sizeof(legSecurityIDSourceValues) - ? length - : sizeof(legSecurityIDSourceValues); + SBE_NODISCARD bool securityReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } - std::memcpy( - dst, legSecurityIDSourceValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityReqIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - std::string getLegSecurityIDSourceAsString() const { - static const std::uint8_t LegSecurityIDSourceValues[] = {56}; + static SBE_CONSTEXPR std::uint64_t securityReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - return std::string((const char *)LegSecurityIDSourceValues, 1); - } + static SBE_CONSTEXPR std::uint64_t securityReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - std::string getLegSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLegSecurityIDSourceAsString(); + static SBE_CONSTEXPR std::uint64_t securityReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + static SBE_CONSTEXPR std::size_t securityReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + SBE_NODISCARD std::uint64_t securityReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + SecurityDefinitionRequest560 &securityReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= manualOrderIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } + + SecurityDefinitionRequest560 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= seqNumSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + SecurityDefinitionRequest560 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= senderIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } + + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 21; + } + + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 21 + (index * 1), sizeof(char)); + return (val); + } + + SecurityDefinitionRequest560 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 21 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 21, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionRequest560 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 21, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char * - LegPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 21; + std::size_t length = 0; - static SBE_CONSTEXPR std::uint16_t legPriceId() SBE_NOEXCEPT { - return 566; - } + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + return result; + } + #endif - SBE_NODISCARD bool legPriceInActingVersion() SBE_NOEXCEPT { + #if __cplusplus >= 201703L + SecurityDefinitionRequest560 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 21, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionRequest560 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 21, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 21 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityReqTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityReqTypeId() SBE_NOEXCEPT + { + return 321; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityReqTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityReqTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legPriceSinceVersion(); + return m_actingVersion >= securityReqTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legPriceEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityReqTypeEncodingOffset() SBE_NOEXCEPT + { + return 41; + } + static SBE_CONSTEXPR char securityReqTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char securityReqTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char securityReqTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t securityReqTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t securityReqTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *securityReqType() const + { + static const std::uint8_t securityReqTypeValues[] = { 49, 0 }; + + return (const char *)securityReqTypeValues; + } + + SBE_NODISCARD char securityReqType(const std::uint64_t index) const + { + static const std::uint8_t securityReqTypeValues[] = { 49, 0 }; + + return (char)securityReqTypeValues[index]; + } + + std::uint64_t getSecurityReqType(char *dst, const std::uint64_t length) const + { + static std::uint8_t securityReqTypeValues[] = { 49 }; + std::uint64_t bytesToCopy = length < sizeof(securityReqTypeValues) ? length : sizeof(securityReqTypeValues); + + std::memcpy(dst, securityReqTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getSecurityReqTypeAsString() const + { + static const std::uint8_t SecurityReqTypeValues[] = { 49 }; + + return std::string((const char *)SecurityReqTypeValues, 1); + } + + std::string getSecurityReqTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityReqTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 41; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 41, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + SecurityDefinitionRequest560 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 41, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecuritySubTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securitySubTypeId() SBE_NOEXCEPT + { + return 762; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securitySubTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securitySubTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securitySubTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securitySubTypeEncodingOffset() SBE_NOEXCEPT + { + return 49; + } + + static SBE_CONSTEXPR char securitySubTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char securitySubTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char securitySubTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t securitySubTypeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t securitySubTypeLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *securitySubType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } + + SBE_NODISCARD char *securitySubType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 49; + } + + SBE_NODISCARD char securitySubType(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for securitySubType [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 49 + (index * 1), sizeof(char)); + return (val); + } + + SecurityDefinitionRequest560 &securitySubType(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for securitySubType [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 49 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getSecuritySubType(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getSecuritySubType [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 49, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionRequest560 &putSecuritySubType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 49, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getSecuritySubTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSecuritySubTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecuritySubTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecuritySubTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 49; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionRequest560 &putSecuritySubType(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putSecuritySubType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 49, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionRequest560 &putSecuritySubType(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putSecuritySubType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 49, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 49 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 57; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 57; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 57; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 57 + (index * 1), sizeof(char)); + return (val); + } + + SecurityDefinitionRequest560 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 57 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 57, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionRequest560 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 57, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 57; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 57; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionRequest560 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 57, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 57 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionRequest560 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 57, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 57 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *StartDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t startDateId() SBE_NOEXCEPT + { + return 916; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t startDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool startDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= startDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t startDateEncodingOffset() SBE_NOEXCEPT + { + return 62; + } + + static SBE_CONSTEXPR std::uint16_t startDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t startDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t startDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t startDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t startDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 62, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + SecurityDefinitionRequest560 &startDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 62, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *EndDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t endDateId() SBE_NOEXCEPT + { + return 917; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t endDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool endDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= endDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t endDateEncodingOffset() SBE_NOEXCEPT + { + return 64; + } + + static SBE_CONSTEXPR std::uint16_t endDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t endDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t endDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t endDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t endDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + SecurityDefinitionRequest560 &endDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *MaxNoOfSubstitutionsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t maxNoOfSubstitutionsId() SBE_NOEXCEPT + { + return 37715; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxNoOfSubstitutionsSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool maxNoOfSubstitutionsInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= maxNoOfSubstitutionsSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxNoOfSubstitutionsEncodingOffset() SBE_NOEXCEPT + { + return 66; + } + + static SBE_CONSTEXPR std::uint8_t maxNoOfSubstitutionsNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t maxNoOfSubstitutionsMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t maxNoOfSubstitutionsMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t maxNoOfSubstitutionsEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t maxNoOfSubstitutions() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return (val); + } + + SecurityDefinitionRequest560 &maxNoOfSubstitutions(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SourceRepoIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sourceRepoIDId() SBE_NOEXCEPT + { + return 5677; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sourceRepoIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sourceRepoIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sourceRepoIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sourceRepoIDEncodingOffset() SBE_NOEXCEPT + { + return 67; + } + + static SBE_CONSTEXPR std::int32_t sourceRepoIDNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t sourceRepoIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t sourceRepoIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t sourceRepoIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t sourceRepoID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 67, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + SecurityDefinitionRequest560 &sourceRepoID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 67, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *BrokenDateTermTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t brokenDateTermTypeId() SBE_NOEXCEPT + { + return 6651; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t brokenDateTermTypeSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool brokenDateTermTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= brokenDateTermTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t brokenDateTermTypeEncodingOffset() SBE_NOEXCEPT + { + return 71; + } + + static SBE_CONSTEXPR std::uint8_t brokenDateTermTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t brokenDateTermTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t brokenDateTermTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t brokenDateTermTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t brokenDateTermType() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); + return (val); + } + + SecurityDefinitionRequest560 &brokenDateTermType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 71, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoLegs + { private: - PRICENULL9 m_legPrice; + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; + + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } public: - SBE_NODISCARD PRICENULL9 &legPrice() { - m_legPrice.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_legPrice; - } + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - SBE_NODISCARD static const char *LegSecurityIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(19)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 19; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - static SBE_CONSTEXPR std::uint16_t legSecurityIDId() SBE_NOEXCEPT { - return 602; - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSecurityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 19; + } - SBE_NODISCARD bool legSecurityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legSecurityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSecurityIDEncodingOffset() SBE_NOEXCEPT { - return 8; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - static SBE_CONSTEXPR std::int32_t legSecurityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - static SBE_CONSTEXPR std::int32_t legSecurityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - static SBE_CONSTEXPR std::int32_t legSecurityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - static SBE_CONSTEXPR std::size_t - legSecurityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + inline NoLegs &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; - SBE_NODISCARD std::int32_t legSecurityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + return *this; + } - NoLegs &legSecurityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::int32_t)); - return *this; - } + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } - SBE_NODISCARD static const char *LegOptionDeltaMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - static SBE_CONSTEXPR std::uint16_t legOptionDeltaId() SBE_NOEXCEPT { - return 1017; - } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legOptionDeltaSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static const char *LegSecurityIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } - SBE_NODISCARD bool legOptionDeltaInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legOptionDeltaSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + static SBE_CONSTEXPR std::uint16_t legSecurityIDSourceId() SBE_NOEXCEPT + { + return 603; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legOptionDeltaEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSecurityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - private: - Decimal32NULL m_legOptionDelta; + SBE_NODISCARD bool legSecurityIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSecurityIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - public: - SBE_NODISCARD Decimal32NULL &legOptionDelta() { - m_legOptionDelta.wrap( - m_buffer, m_offset + 12, m_actingVersion, m_bufferLength); - return m_legOptionDelta; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSecurityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD static const char * - LegSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR char legSecurityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT { - return 624; - } + static SBE_CONSTEXPR char legSecurityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSideSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR char legSecurityIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - SBE_NODISCARD bool legSideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legSideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + static SBE_CONSTEXPR std::size_t legSecurityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingOffset() SBE_NOEXCEPT { - return 17; - } + static SBE_CONSTEXPR std::uint64_t legSecurityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD const char *legSecurityIDSource() const + { + static const std::uint8_t legSecurityIDSourceValues[] = { 56, 0 }; - SBE_NODISCARD SideReq::Value legSide() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + return (const char *)legSecurityIDSourceValues; + } - NoLegs &legSide(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD char legSecurityIDSource(const std::uint64_t index) const + { + static const std::uint8_t legSecurityIDSourceValues[] = { 56, 0 }; - SBE_NODISCARD static const char * - LegRatioQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + return (char)legSecurityIDSourceValues[index]; + } - static SBE_CONSTEXPR std::uint16_t legRatioQtyId() SBE_NOEXCEPT { - return 623; - } + std::uint64_t getLegSecurityIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t legSecurityIDSourceValues[] = { 56 }; + std::uint64_t bytesToCopy = length < sizeof(legSecurityIDSourceValues) ? length : sizeof(legSecurityIDSourceValues); - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legRatioQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + std::memcpy(dst, legSecurityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - SBE_NODISCARD bool legRatioQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= legRatioQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + std::string getLegSecurityIDSourceAsString() const + { + static const std::uint8_t LegSecurityIDSourceValues[] = { 56 }; - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legRatioQtyEncodingOffset() SBE_NOEXCEPT { - return 18; - } + return std::string((const char *)LegSecurityIDSourceValues, 1); + } - static SBE_CONSTEXPR std::uint8_t legRatioQtyNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + std::string getLegSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLegSecurityIDSourceAsString(); - static SBE_CONSTEXPR std::uint8_t legRatioQtyMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - static SBE_CONSTEXPR std::uint8_t legRatioQtyMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } - static SBE_CONSTEXPR std::size_t - legRatioQtyEncodingLength() SBE_NOEXCEPT { - return 1; - } + return oss.str(); + } - SBE_NODISCARD std::uint8_t legRatioQty() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD static const char *LegPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - NoLegs &legRatioQty(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 18, &val, sizeof(std::uint8_t)); - return *this; - } + static SBE_CONSTEXPR std::uint16_t legPriceId() SBE_NOEXCEPT + { + return 566; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoLegs writer) { - builder << '{'; - builder << R"("LegPrice": )"; - builder << writer.legPrice(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("LegSecurityID": )"; - builder << +writer.legSecurityID(); + SBE_NODISCARD bool legPriceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legPriceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - builder << ", "; - builder << R"("LegOptionDelta": )"; - builder << writer.legOptionDelta(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legPriceEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("LegSide": )"; - builder << '"' << writer.legSide() << '"'; +private: + PRICENULL9 m_legPrice; - builder << ", "; - builder << R"("LegRatioQty": )"; - builder << +writer.legRatioQty(); +public: + SBE_NODISCARD PRICENULL9 &legPrice() + { + m_legPrice.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_legPrice; + } - builder << '}'; + SBE_NODISCARD static const char *LegSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - return builder; - } + static SBE_CONSTEXPR std::uint16_t legSecurityIDId() SBE_NOEXCEPT + { + return 602; + } - void skip() {} + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSecurityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + SBE_NODISCARD bool legSecurityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSecurityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSecurityIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::int32_t legSecurityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t legSecurityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t legSecurityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t legSecurityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t legSecurityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoLegs &legSecurityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *LegOptionDeltaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "float"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legOptionDeltaId() SBE_NOEXCEPT + { + return 1017; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legOptionDeltaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legOptionDeltaInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legOptionDeltaSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legOptionDeltaEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + +private: + Decimal32NULL m_legOptionDelta; + +public: + SBE_NODISCARD Decimal32NULL &legOptionDelta() + { + m_legOptionDelta.wrap(m_buffer, m_offset + 12, m_actingVersion, m_bufferLength); + return m_legOptionDelta; + } + + SBE_NODISCARD static const char *LegSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT + { + return 624; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legSideInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSideSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t legSideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value legSide() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + NoLegs &legSide(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *LegRatioQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legRatioQtyId() SBE_NOEXCEPT + { + return 623; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legRatioQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legRatioQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legRatioQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legRatioQtyEncodingOffset() SBE_NOEXCEPT + { + return 18; + } + + static SBE_CONSTEXPR std::uint8_t legRatioQtyNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t legRatioQtyMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t legRatioQtyMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t legRatioQtyEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t legRatioQty() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return (val); + } + + NoLegs &legRatioQty(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 18, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoLegs writer) + { + builder << '{'; + builder << R"("LegPrice": )"; + builder << writer.legPrice(); + + builder << ", "; + builder << R"("LegSecurityID": )"; + builder << +writer.legSecurityID(); + + builder << ", "; + builder << R"("LegOptionDelta": )"; + builder << writer.legOptionDelta(); + + builder << ", "; + builder << R"("LegSide": )"; + builder << '"' << writer.legSide() << '"'; + + builder << ", "; + builder << R"("LegRatioQty": )"; + builder << +writer.legRatioQty(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoLegs m_noLegs; +private: + NoLegs m_noLegs; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT { - return 555; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT + { + return 555; + } - SBE_NODISCARD inline NoLegs &noLegs() { - m_noLegs.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + SBE_NODISCARD inline NoLegs &noLegs() + { + m_noLegs.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLegs; + } - NoLegs &noLegsCount(const std::uint8_t count) { - m_noLegs.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + NoLegs &noLegsCount(const std::uint8_t count) + { + m_noLegs.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLegs; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLegsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLegsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noLegsSinceVersion(); + return m_actingVersion >= noLegsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - SecurityDefinitionRequest560 _writer) { - SecurityDefinitionRequest560 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "SecurityDefinitionRequest560", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + class NoBrokenDates + { + private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } - builder << ", "; - builder << R"("SecurityReqID": )"; - builder << +writer.securityReqID(); + public: + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("SecuritySubType": )"; - builder << '"' << writer.getSecuritySubTypeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("StartDate": )"; - builder << +writer.startDate(); - - builder << ", "; - builder << R"("EndDate": )"; - builder << +writer.endDate(); - - builder << ", "; - builder << R"("MaxNoOfSubstitutions": )"; - builder << +writer.maxNoOfSubstitutions(); - - builder << ", "; - builder << R"("SourceRepoID": )"; - builder << +writer.sourceRepoID(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLegs": [)"; - writer.noLegs().forEach([&](NoLegs &noLegs) { - if (atLeastOne) { - builder << ", "; + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - atLeastOne = true; - builder << noLegs; - }); - builder << ']'; - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(4)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 4; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - return builder; - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 4; + } - void skip() { - noLegs().forEach([](NoLegs e) { e.skip(); }); - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t NoLegsLength = 0) { + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoBrokenDates &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *BrokenDateStartMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t brokenDateStartId() SBE_NOEXCEPT + { + return 6748; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t brokenDateStartSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool brokenDateStartInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= brokenDateStartSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t brokenDateStartEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint16_t brokenDateStartNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t brokenDateStartMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t brokenDateStartMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t brokenDateStartEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t brokenDateStart() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoBrokenDates &brokenDateStart(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *BrokenDateEndMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t brokenDateEndId() SBE_NOEXCEPT + { + return 6741; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t brokenDateEndSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool brokenDateEndInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= brokenDateEndSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t brokenDateEndEncodingOffset() SBE_NOEXCEPT + { + return 2; + } + + static SBE_CONSTEXPR std::uint16_t brokenDateEndNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t brokenDateEndMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t brokenDateEndMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t brokenDateEndEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t brokenDateEnd() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 2, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoBrokenDates &brokenDateEnd(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 2, &val, sizeof(std::uint16_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoBrokenDates writer) + { + builder << '{'; + builder << R"("BrokenDateStart": )"; + builder << +writer.brokenDateStart(); + + builder << ", "; + builder << R"("BrokenDateEnd": )"; + builder << +writer.brokenDateEnd(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoLegs::sbeHeaderSize(); - if (NoLegsLength > 254) { - throw std::runtime_error( - "NoLegsLength outside of allowed range [E110]"); - } - length += NoLegsLength * NoLegs::sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } + } + }; + +private: + NoBrokenDates m_noBrokenDates; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoBrokenDatesId() SBE_NOEXCEPT + { + return 39026; + } + + SBE_NODISCARD inline NoBrokenDates &noBrokenDates() + { + m_noBrokenDates.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noBrokenDates; + } + + NoBrokenDates &noBrokenDatesCount(const std::uint8_t count) + { + m_noBrokenDates.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noBrokenDates; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noBrokenDatesSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool noBrokenDatesInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noBrokenDatesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, SecurityDefinitionRequest560 _writer) +{ + SecurityDefinitionRequest560 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "SecurityDefinitionRequest560", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("SecurityReqID": )"; + builder << +writer.securityReqID(); + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("SecuritySubType": )"; + builder << '"' << + writer.getSecuritySubTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("StartDate": )"; + builder << +writer.startDate(); + + builder << ", "; + builder << R"("EndDate": )"; + builder << +writer.endDate(); + + builder << ", "; + builder << R"("MaxNoOfSubstitutions": )"; + builder << +writer.maxNoOfSubstitutions(); + + builder << ", "; + builder << R"("SourceRepoID": )"; + builder << +writer.sourceRepoID(); + + builder << ", "; + builder << R"("BrokenDateTermType": )"; + builder << +writer.brokenDateTermType(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLegs": [)"; + writer.noLegs().forEach( + [&](NoLegs &noLegs) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noLegs; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoBrokenDates": [)"; + writer.noBrokenDates().forEach( + [&](NoBrokenDates &noBrokenDates) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noBrokenDates; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noLegsGroup { noLegs() }; + while (noLegsGroup.hasNext()) + { + noLegsGroup.next().skip(); + } + auto &noBrokenDatesGroup { noBrokenDates() }; + while (noBrokenDatesGroup.hasNext()) + { + noBrokenDatesGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noLegsLength = 0, + std::size_t noBrokenDatesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoLegs::sbeHeaderSize(); + if (noLegsLength > 254LL) + { + throw std::runtime_error("noLegsLength outside of allowed range [E110]"); + } + length += noLegsLength *NoLegs::sbeBlockLength(); + + length += NoBrokenDates::sbeHeaderSize(); + if (noBrokenDatesLength > 254LL) + { + throw std::runtime_error("noBrokenDatesLength outside of allowed range [E110]"); + } + length += noBrokenDatesLength *NoBrokenDates::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/SecurityDefinitionResponse561.h b/src/lib/orderman/ilink3/generated/SecurityDefinitionResponse561.h index c53a5f78c..cd1dd372c 100644 --- a/src/lib/orderman/ilink3/generated/SecurityDefinitionResponse561.h +++ b/src/lib/orderman/ilink3/generated/SecurityDefinitionResponse561.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,4281 +86,5164 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class SecurityDefinitionResponse561 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; - - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } - - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; - - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; - - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; - - SecurityDefinitionResponse561() = default; - - SecurityDefinitionResponse561( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} - - SecurityDefinitionResponse561(char *buffer, const std::uint64_t bufferLength) - : SecurityDefinitionResponse561( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} - - SecurityDefinitionResponse561( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : SecurityDefinitionResponse561( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)429; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)561; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } - - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "d"; - } - - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } - - SecurityDefinitionResponse561 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = SecurityDefinitionResponse561( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } - - SecurityDefinitionResponse561 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); - - return *this = SecurityDefinitionResponse561( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } - - SecurityDefinitionResponse561 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = SecurityDefinitionResponse561( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } - - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } - - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } - - SBE_NODISCARD std::uint64_t decodeLength() const { - SecurityDefinitionResponse561 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } - - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } - - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } - - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } - - SBE_NODISCARD static const char * - SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT { return 9726; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - seqNumSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= seqNumSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - seqNumEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - SecurityDefinitionResponse561 & - seqNum(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= uUIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - SecurityDefinitionResponse561 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= textSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT { return (char)126; } - - static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT { - return 256; - } - - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 256; } - - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 12; - } - - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 12; } - - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionResponse561 & - text(const std::uint64_t index, const char value) { - if (index >= 256) { - throw std::runtime_error("index out of range for text [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getText(char *const dst, const std::uint64_t length) const { - if (length > 256) { - throw std::runtime_error("length too large for getText [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 12, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionResponse561 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); - return *this; - } - - SBE_NODISCARD std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getTextAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTextAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 12; - size_t length = 0; - - for (; length < 256 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionResponse561 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionResponse561 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 256) { - throw std::runtime_error("string too large for putText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); - for (size_t start = srcLength; start < 256; ++start) { - m_buffer[m_offset + 12 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *FinancialInstrumentFullNameMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t - financialInstrumentFullNameId() SBE_NOEXCEPT { - return 2714; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - financialInstrumentFullNameSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool - financialInstrumentFullNameInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= financialInstrumentFullNameSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - financialInstrumentFullNameEncodingOffset() SBE_NOEXCEPT { - return 268; - } - - static SBE_CONSTEXPR char - financialInstrumentFullNameNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char - financialInstrumentFullNameMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char - financialInstrumentFullNameMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - financialInstrumentFullNameEncodingLength() SBE_NOEXCEPT { - return 35; - } - - static SBE_CONSTEXPR std::uint64_t - financialInstrumentFullNameLength() SBE_NOEXCEPT { - return 35; - } - - SBE_NODISCARD const char *financialInstrumentFullName() const SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } - - SBE_NODISCARD char *financialInstrumentFullName() SBE_NOEXCEPT { - return m_buffer + m_offset + 268; - } - - SBE_NODISCARD char - financialInstrumentFullName(const std::uint64_t index) const { - if (index >= 35) { - throw std::runtime_error( - "index out of range for financialInstrumentFullName [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionResponse561 & - financialInstrumentFullName(const std::uint64_t index, const char value) { - if (index >= 35) { - throw std::runtime_error( - "index out of range for financialInstrumentFullName [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getFinancialInstrumentFullName( - char *const dst, const std::uint64_t length) const { - if (length > 35) { - throw std::runtime_error( - "length too large for getFinancialInstrumentFullName [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 268, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionResponse561 & - putFinancialInstrumentFullName(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 35); - return *this; - } - - SBE_NODISCARD std::string getFinancialInstrumentFullNameAsString() const { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; - - for (; length < 35 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getFinancialInstrumentFullNameAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getFinancialInstrumentFullNameAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getFinancialInstrumentFullNameAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 268; - size_t length = 0; - - for (; length < 35 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionResponse561 & - putFinancialInstrumentFullName(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 35) { - throw std::runtime_error( - "string too large for putFinancialInstrumentFullName [E106]"); - } - - std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); - for (size_t start = srcLength; start < 35; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionResponse561 & - putFinancialInstrumentFullName(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 35) { - throw std::runtime_error( - "string too large for putFinancialInstrumentFullName [E106]"); - } - - std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); - for (size_t start = srcLength; start < 35; ++start) { - m_buffer[m_offset + 268 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT { return 5392; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - senderIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= senderIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - senderIDEncodingOffset() SBE_NOEXCEPT { - return 303; - } - - static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 303; - } - - SBE_NODISCARD char *senderID() SBE_NOEXCEPT { - return m_buffer + m_offset + 303; - } - - SBE_NODISCARD char senderID(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 303 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionResponse561 & - senderID(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for senderID [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 303 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSenderID(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSenderID [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 303, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionResponse561 & - putSenderID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 303, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSenderIDAsString() const { - const char *buffer = m_buffer + m_offset + 303; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSenderIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSenderIDAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 303; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionResponse561 &putSenderID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 303, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 303 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionResponse561 &putSenderID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSenderID [E106]"); - } - - std::memcpy(m_buffer + m_offset + 303, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 303 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t symbolId() SBE_NOEXCEPT { return 55; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - symbolSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= symbolSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - symbolEncodingOffset() SBE_NOEXCEPT { - return 323; - } - - static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT { return (char)0; } - - static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT { return (char)32; } - - static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT { return (char)126; } - - static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t symbolLength() SBE_NOEXCEPT { return 20; } - - SBE_NODISCARD const char *symbol() const SBE_NOEXCEPT { - return m_buffer + m_offset + 323; - } - - SBE_NODISCARD char *symbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 323; - } - - SBE_NODISCARD char symbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 323 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionResponse561 & - symbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 323 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t getSymbol(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error("length too large for getSymbol [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 323, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionResponse561 & - putSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 323, src, sizeof(char) * 20); - return *this; - } - - SBE_NODISCARD std::string getSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 323; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSymbolAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 323; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionResponse561 &putSymbol(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 323, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 323 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionResponse561 &putSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 323, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 323 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT { - return 1505; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= partyDetailsListReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT { - return 343; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - partyDetailsListReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 343, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - SecurityDefinitionResponse561 & - partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 343, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecurityReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityReqIDId() SBE_NOEXCEPT { - return 320; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityReqIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityReqIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityReqIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityReqIDEncodingOffset() SBE_NOEXCEPT { - return 351; - } - - static SBE_CONSTEXPR std::uint64_t securityReqIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t securityReqIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t securityReqIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t securityReqIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t securityReqID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 351, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - SecurityDefinitionResponse561 & - securityReqID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 351, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SecurityResponseIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityResponseIDId() SBE_NOEXCEPT { - return 322; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityResponseIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityResponseIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityResponseIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityResponseIDEncodingOffset() SBE_NOEXCEPT { - return 359; - } - - static SBE_CONSTEXPR std::uint64_t - securityResponseIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t - securityResponseIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - securityResponseIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - securityResponseIDEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t securityResponseID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 359, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - SecurityDefinitionResponse561 & - securityResponseID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 359, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT { - return 5297; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sendingTimeEpochSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sendingTimeEpochSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingOffset() SBE_NOEXCEPT { - return 367; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - sendingTimeEpochEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 367, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - SecurityDefinitionResponse561 & - sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 367, &val, sizeof(std::uint64_t)); - return *this; - } - - SBE_NODISCARD static const char * - SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT { - return 1151; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityGroupSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityGroupSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityGroupEncodingOffset() SBE_NOEXCEPT { - return 375; - } - - static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT { - return 6; - } - - static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT { - return 6; - } - - SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT { - return m_buffer + m_offset + 375; - } - - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 375; - } - - SBE_NODISCARD char securityGroup(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 375 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionResponse561 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 375 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSecurityGroup(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error( - "length too large for getSecurityGroup [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 375, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionResponse561 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 375, src, sizeof(char) * 6); - return *this; - } - - SBE_NODISCARD std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 375; - size_t length = 0; - - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSecurityGroupAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityGroupAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 375; - size_t length = 0; - - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionResponse561 &putSecurityGroup(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } - - std::memcpy(m_buffer + m_offset + 375, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 375 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionResponse561 &putSecurityGroup(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityGroup [E106]"); - } - - std::memcpy(m_buffer + m_offset + 375, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 375 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SecurityTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityTypeId() SBE_NOEXCEPT { - return 167; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTypeEncodingOffset() SBE_NOEXCEPT { - return 381; - } - - static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char securityTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t securityTypeEncodingLength() SBE_NOEXCEPT { - return 6; - } - - static SBE_CONSTEXPR std::uint64_t securityTypeLength() SBE_NOEXCEPT { - return 6; - } - - SBE_NODISCARD const char *securityType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 381; - } - - SBE_NODISCARD char *securityType() SBE_NOEXCEPT { - return m_buffer + m_offset + 381; - } - - SBE_NODISCARD char securityType(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 381 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionResponse561 & - securityType(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 381 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getSecurityType(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error( - "length too large for getSecurityType [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 381, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionResponse561 & - putSecurityType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 381, src, sizeof(char) * 6); - return *this; - } - - SBE_NODISCARD std::string getSecurityTypeAsString() const { - const char *buffer = m_buffer + m_offset + 381; - size_t length = 0; - - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getSecurityTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityTypeAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getSecurityTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 381; - size_t length = 0; - - for (; length < 6 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionResponse561 &putSecurityType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 381, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 381 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionResponse561 &putSecurityType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 381, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 381 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT { return 9537; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - locationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= locationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - locationEncodingOffset() SBE_NOEXCEPT { - return 387; - } - - static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT { - return 5; - } - - static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT { - return 5; - } - - SBE_NODISCARD const char *location() const SBE_NOEXCEPT { - return m_buffer + m_offset + 387; - } - - SBE_NODISCARD char *location() SBE_NOEXCEPT { - return m_buffer + m_offset + 387; - } - - SBE_NODISCARD char location(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 387 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionResponse561 & - location(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error("index out of range for location [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 387 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getLocation(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error("length too large for getLocation [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 387, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionResponse561 & - putLocation(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 387, src, sizeof(char) * 5); - return *this; - } - - SBE_NODISCARD std::string getLocationAsString() const { - const char *buffer = m_buffer + m_offset + 387; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getLocationAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLocationAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 387; - size_t length = 0; - - for (; length < 5 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionResponse561 &putLocation(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 387, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 387 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionResponse561 &putLocation(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error("string too large for putLocation [E106]"); - } - - std::memcpy(m_buffer + m_offset + 387, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 387 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT { return 48; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDEncodingOffset() SBE_NOEXCEPT { - return 392; - } - - static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 392, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - SecurityDefinitionResponse561 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 392, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t currencyId() SBE_NOEXCEPT { return 15; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - currencySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= currencySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - currencyEncodingOffset() SBE_NOEXCEPT { - return 396; - } - - static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char currencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t currencyEncodingLength() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t currencyLength() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD const char *currency() const SBE_NOEXCEPT { - return m_buffer + m_offset + 396; - } - - SBE_NODISCARD char *currency() SBE_NOEXCEPT { - return m_buffer + m_offset + 396; - } - - SBE_NODISCARD char currency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 396 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionResponse561 & - currency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 396 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getCurrency(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error("length too large for getCurrency [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 396, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionResponse561 & - putCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 396, src, sizeof(char) * 3); - return *this; - } - - SecurityDefinitionResponse561 &putCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 396, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 397, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 398, &val2, sizeof(char)); - - return *this; - } - - SBE_NODISCARD std::string getCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 396; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCurrencyAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 396; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionResponse561 &putCurrency(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putCurrency [E106]"); - } - - std::memcpy(m_buffer + m_offset + 396, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 396 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionResponse561 &putCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putCurrency [E106]"); - } - - std::memcpy(m_buffer + m_offset + 396, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 396 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *SecurityIDSourceMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityIDSourceId() SBE_NOEXCEPT { - return 22; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 399; - } - - static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char securityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - securityIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *securityIDSource() const { - static const std::uint8_t securityIDSourceValues[] = {56}; - - return (const char *)securityIDSourceValues; - } - - SBE_NODISCARD char securityIDSource(const std::uint64_t index) const { - static const std::uint8_t securityIDSourceValues[] = {56}; - - return (char)securityIDSourceValues[index]; - } - - std::uint64_t - getSecurityIDSource(char *dst, const std::uint64_t length) const { - static std::uint8_t securityIDSourceValues[] = {56}; - std::uint64_t bytesToCopy = length < sizeof(securityIDSourceValues) - ? length - : sizeof(securityIDSourceValues); - - std::memcpy( - dst, securityIDSourceValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getSecurityIDSourceAsString() const { - static const std::uint8_t SecurityIDSourceValues[] = {56}; - - return std::string((const char *)SecurityIDSourceValues, 1); - } - - std::string getSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityIDSourceAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char *MaturityMonthYearMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MonthYear"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t maturityMonthYearId() SBE_NOEXCEPT { - return 200; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maturityMonthYearSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= maturityMonthYearSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maturityMonthYearEncodingOffset() SBE_NOEXCEPT { - return 399; - } - - private: - MaturityMonthYear m_maturityMonthYear; - - public: - SBE_NODISCARD MaturityMonthYear &maturityMonthYear() { - m_maturityMonthYear.wrap( - m_buffer, m_offset + 399, m_actingVersion, m_bufferLength); - return m_maturityMonthYear; - } - - SBE_NODISCARD static const char * - DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT { - return 5904; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - delayDurationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= delayDurationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - delayDurationEncodingOffset() SBE_NOEXCEPT { - return 404; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 404, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - SecurityDefinitionResponse561 & - delayDuration(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 404, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - StartDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t startDateId() SBE_NOEXCEPT { return 916; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - startDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool startDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= startDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - startDateEncodingOffset() SBE_NOEXCEPT { - return 406; - } - - static SBE_CONSTEXPR std::uint16_t startDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t startDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t startDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t startDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t startDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 406, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - SecurityDefinitionResponse561 & - startDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 406, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char * - EndDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "LocalMktDate"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t endDateId() SBE_NOEXCEPT { return 917; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - endDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool endDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= endDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - endDateEncodingOffset() SBE_NOEXCEPT { - return 408; - } - - static SBE_CONSTEXPR std::uint16_t endDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t endDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t endDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t endDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t endDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 408, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - SecurityDefinitionResponse561 & - endDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 408, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char *MaxNoOfSubstitutionsMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t maxNoOfSubstitutionsId() SBE_NOEXCEPT { - return 37715; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxNoOfSubstitutionsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool maxNoOfSubstitutionsInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= maxNoOfSubstitutionsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxNoOfSubstitutionsEncodingOffset() SBE_NOEXCEPT { - return 410; - } - - static SBE_CONSTEXPR std::uint8_t - maxNoOfSubstitutionsNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } - - static SBE_CONSTEXPR std::uint8_t - maxNoOfSubstitutionsMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t - maxNoOfSubstitutionsMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - maxNoOfSubstitutionsEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t maxNoOfSubstitutions() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 410, sizeof(std::uint8_t)); - return (val); - } - - SecurityDefinitionResponse561 & - maxNoOfSubstitutions(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 410, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - SourceRepoIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t sourceRepoIDId() SBE_NOEXCEPT { - return 5677; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - sourceRepoIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool sourceRepoIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= sourceRepoIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - sourceRepoIDEncodingOffset() SBE_NOEXCEPT { - return 411; - } - - static SBE_CONSTEXPR std::int32_t sourceRepoIDNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t sourceRepoIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t sourceRepoIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t sourceRepoIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t sourceRepoID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 411, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - SecurityDefinitionResponse561 & - sourceRepoID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 411, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char *TerminationTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t terminationTypeId() SBE_NOEXCEPT { - return 788; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - terminationTypeSinceVersion() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD bool terminationTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= terminationTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - terminationTypeEncodingOffset() SBE_NOEXCEPT { - return 415; - } - - static SBE_CONSTEXPR char terminationTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char terminationTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char terminationTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - terminationTypeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t terminationTypeLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD const char *terminationType() const SBE_NOEXCEPT { - if (m_actingVersion < 3) { - return nullptr; - } - - return m_buffer + m_offset + 415; - } - - SBE_NODISCARD char *terminationType() SBE_NOEXCEPT { - if (m_actingVersion < 3) { - return nullptr; - } - - return m_buffer + m_offset + 415; - } - - SBE_NODISCARD char terminationType(const std::uint64_t index) const { - if (index >= 8) { - throw std::runtime_error( - "index out of range for terminationType [E104]"); - } - - if (m_actingVersion < 3) { - return (char)0; - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 415 + (index * 1), sizeof(char)); - return (val); - } - - SecurityDefinitionResponse561 & - terminationType(const std::uint64_t index, const char value) { - if (index >= 8) { - throw std::runtime_error( - "index out of range for terminationType [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 415 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getTerminationType(char *const dst, const std::uint64_t length) const { - if (length > 8) { - throw std::runtime_error( - "length too large for getTerminationType [E106]"); - } - - if (m_actingVersion < 3) { - return 0; - } - - std::memcpy( - dst, m_buffer + m_offset + 415, - sizeof(char) * static_cast(length)); - return length; - } - - SecurityDefinitionResponse561 & - putTerminationType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 415, src, sizeof(char) * 8); - return *this; - } - - SBE_NODISCARD std::string getTerminationTypeAsString() const { - const char *buffer = m_buffer + m_offset + 415; - size_t length = 0; - - for (; length < 8 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getTerminationTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getTerminationTypeAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view - getTerminationTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 415; - size_t length = 0; - - for (; length < 8 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - SecurityDefinitionResponse561 & - putTerminationType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 8) { - throw std::runtime_error( - "string too large for putTerminationType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 415, str.data(), srcLength); - for (size_t start = srcLength; start < 8; ++start) { - m_buffer[m_offset + 415 + start] = 0; - } - - return *this; - } -#else - SecurityDefinitionResponse561 &putTerminationType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 8) { - throw std::runtime_error( - "string too large for putTerminationType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 415, str.c_str(), srcLength); - for (size_t start = srcLength; start < 8; ++start) { - m_buffer[m_offset + 415 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char *SecurityResponseTypeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t securityResponseTypeId() SBE_NOEXCEPT { - return 323; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityResponseTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool securityResponseTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= securityResponseTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityResponseTypeEncodingOffset() SBE_NOEXCEPT { - return 423; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityResponseTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SecRspTyp::Value securityResponseType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 423, sizeof(std::uint8_t)); - return SecRspTyp::get((val)); - } - - SecurityDefinitionResponse561 & - securityResponseType(const SecRspTyp::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 423, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *UserDefinedInstrumentMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t userDefinedInstrumentId() SBE_NOEXCEPT { - return 9779; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - userDefinedInstrumentSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= userDefinedInstrumentSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT { - return 424; - } - - static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - userDefinedInstrumentLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *userDefinedInstrument() const { - static const std::uint8_t userDefinedInstrumentValues[] = {89}; - - return (const char *)userDefinedInstrumentValues; - } - - SBE_NODISCARD char userDefinedInstrument(const std::uint64_t index) const { - static const std::uint8_t userDefinedInstrumentValues[] = {89}; - - return (char)userDefinedInstrumentValues[index]; - } - - std::uint64_t - getUserDefinedInstrument(char *dst, const std::uint64_t length) const { - static std::uint8_t userDefinedInstrumentValues[] = {89}; - std::uint64_t bytesToCopy = length < sizeof(userDefinedInstrumentValues) - ? length - : sizeof(userDefinedInstrumentValues); - - std::memcpy( - dst, userDefinedInstrumentValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getUserDefinedInstrumentAsString() const { - static const std::uint8_t UserDefinedInstrumentValues[] = {89}; - - return std::string((const char *)UserDefinedInstrumentValues, 1); - } - - std::string getUserDefinedInstrumentAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUserDefinedInstrumentAsString(); - - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; - - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } - } - } - - return oss.str(); - } - - SBE_NODISCARD static const char *ExpirationCycleMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t expirationCycleId() SBE_NOEXCEPT { - return 827; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - expirationCycleSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool expirationCycleInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= expirationCycleSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expirationCycleEncodingOffset() SBE_NOEXCEPT { - return 424; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - expirationCycleEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ExpCycle::Value expirationCycle() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 424, sizeof(std::uint8_t)); - return ExpCycle::get((val)); - } - - SecurityDefinitionResponse561 & - expirationCycle(const ExpCycle::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 424, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT { - return 1028; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - manualOrderIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= manualOrderIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT { - return 425; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - manualOrderIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD ManualOrdIndReq::Value - manualOrderIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 425, sizeof(std::uint8_t)); - return ManualOrdIndReq::get((val)); - } - - SecurityDefinitionResponse561 & - manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 425, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= splitMsgSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 426; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 426, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } - - SecurityDefinitionResponse561 & - splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 426, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *AutoQuoteRequestMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t autoQuoteRequestId() SBE_NOEXCEPT { - return 9776; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - autoQuoteRequestSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool autoQuoteRequestInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= autoQuoteRequestSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - autoQuoteRequestEncodingOffset() SBE_NOEXCEPT { - return 427; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - autoQuoteRequestEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value autoQuoteRequest() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 427, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - SecurityDefinitionResponse561 & - autoQuoteRequest(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 427, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *PossRetransFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT { - return 9765; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - possRetransFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= possRetransFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingOffset() SBE_NOEXCEPT { - return 428; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - possRetransFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD BooleanFlag::Value possRetransFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 428, sizeof(std::uint8_t)); - return BooleanFlag::get((val)); - } - - SecurityDefinitionResponse561 & - possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 428, &val, sizeof(std::uint8_t)); - return *this; - } - - class NoLegs { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_initialPosition = 0; - std::uint64_t *m_positionPtr = nullptr; - std::uint64_t m_blockLength = 0; - std::uint64_t m_count = 0; - std::uint64_t m_index = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; - - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } - - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - m_buffer = buffer; - m_bufferLength = bufferLength; - m_blockLength = dimensions.blockLength(); - m_count = dimensions.numInGroup(); - m_index = 0; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wtype-limits" -#endif - if (count > 254) { - throw std::runtime_error("count outside of allowed range [E110]"); - } -#if defined(__GNUG__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif - m_buffer = buffer; - m_bufferLength = bufferLength; - GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)19); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 19; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 19; - } - - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return *m_positionPtr; - } - - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { +class SecurityDefinitionResponse561 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; + + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } + +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(430); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(561); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); + + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; + + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; + + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; + + using messageHeader = MessageHeader; + + SecurityDefinitionResponse561() = default; + + SecurityDefinitionResponse561( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } + + SecurityDefinitionResponse561(char *buffer, const std::uint64_t bufferLength) : + SecurityDefinitionResponse561(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } + + SecurityDefinitionResponse561( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + SecurityDefinitionResponse561(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(430); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(561); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } + + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "d"; + } + + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } + + SecurityDefinitionResponse561 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = SecurityDefinitionResponse561(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } + + SecurityDefinitionResponse561 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); + + return *this = SecurityDefinitionResponse561( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } + + SecurityDefinitionResponse561 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = SecurityDefinitionResponse561(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } + + SecurityDefinitionResponse561 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + } + return position; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT { - return m_count; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT { - return m_index < m_count; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + SecurityDefinitionResponse561 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoLegs &next() { - if (m_index >= m_count) { - throw std::runtime_error("index >= count [E108]"); - } - m_offset = *m_positionPtr; - if (SBE_BOUNDS_CHECK_EXPECT( - ((m_offset + m_blockLength) > m_bufferLength), false)) { - throw std::runtime_error( - "buffer too short for next group index [E108]"); - } - *m_positionPtr = m_offset + m_blockLength; - ++m_index; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - return *this; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT { - m_count = m_index; - GroupSize dimensions( - m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); - dimensions.numInGroup((std::uint8_t)m_count); - return m_count; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } -#if __cplusplus < 201103L - template inline void forEach(Func &func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } -#else - template inline void forEach(Func &&func) { - while (hasNext()) { - next(); - func(*this); - } - } + SBE_NODISCARD static const char *SeqNumMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t seqNumId() SBE_NOEXCEPT + { + return 9726; + } - SBE_NODISCARD static const char * - LegPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Price"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t seqNumSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t legPriceId() SBE_NOEXCEPT { - return 566; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool legPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool seqNumInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legPriceSinceVersion(); + return m_actingVersion >= seqNumSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legPriceEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t seqNumEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - PRICENULL9 m_legPrice; + static SBE_CONSTEXPR std::uint32_t seqNumNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - public: - SBE_NODISCARD PRICENULL9 &legPrice() { - m_legPrice.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_legPrice; - } + static SBE_CONSTEXPR std::uint32_t seqNumMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - SBE_NODISCARD static const char *LegOptionDeltaMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint32_t seqNumMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::uint16_t legOptionDeltaId() SBE_NOEXCEPT { - return 1017; - } + static SBE_CONSTEXPR std::size_t seqNumEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legOptionDeltaSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint32_t seqNum() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SBE_NODISCARD bool legOptionDeltaInActingVersion() SBE_NOEXCEPT { + SecurityDefinitionResponse561 &seqNum(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legOptionDeltaSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legOptionDeltaEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - private: - Decimal32NULL m_legOptionDelta; + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - public: - SBE_NODISCARD Decimal32NULL &legOptionDelta() { - m_legOptionDelta.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_legOptionDelta; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - SBE_NODISCARD static const char *LegSecurityIDSourceMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "char"; - case MetaAttribute::PRESENCE: - return "constant"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::uint16_t legSecurityIDSourceId() SBE_NOEXCEPT { - return 603; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSecurityIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SBE_NODISCARD bool legSecurityIDSourceInActingVersion() SBE_NOEXCEPT { + SecurityDefinitionResponse561 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 4, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT + { + return 58; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t textSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legSecurityIDSourceSinceVersion(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSecurityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 13; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR char legSecurityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char textNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char legSecurityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char textMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char legSecurityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char textMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - legSecurityIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 256; + } - static SBE_CONSTEXPR std::uint64_t - legSecurityIDSourceLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 256; + } - SBE_NODISCARD const char *legSecurityIDSource() const { - static const std::uint8_t legSecurityIDSourceValues[] = {56}; + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - return (const char *)legSecurityIDSourceValues; - } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 12; + } - SBE_NODISCARD char legSecurityIDSource(const std::uint64_t index) const { - static const std::uint8_t legSecurityIDSourceValues[] = {56}; + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E104]"); + } - return (char)legSecurityIDSourceValues[index]; - } + char val; + std::memcpy(&val, m_buffer + m_offset + 12 + (index * 1), sizeof(char)); + return (val); + } - std::uint64_t - getLegSecurityIDSource(char *dst, const std::uint64_t length) const { - static std::uint8_t legSecurityIDSourceValues[] = {56}; - std::uint64_t bytesToCopy = length < sizeof(legSecurityIDSourceValues) - ? length - : sizeof(legSecurityIDSourceValues); + SecurityDefinitionResponse561 &text(const std::uint64_t index, const char value) + { + if (index >= 256) + { + throw std::runtime_error("index out of range for text [E105]"); + } - std::memcpy( - dst, legSecurityIDSourceValues, static_cast(bytesToCopy)); - return bytesToCopy; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 12 + (index * 1), &val, sizeof(char)); + return *this; + } - std::string getLegSecurityIDSourceAsString() const { - static const std::uint8_t LegSecurityIDSourceValues[] = {56}; + std::uint64_t getText(char *const dst, const std::uint64_t length) const + { + if (length > 256) + { + throw std::runtime_error("length too large for getText [E106]"); + } - return std::string((const char *)LegSecurityIDSourceValues, 1); - } + std::memcpy(dst, m_buffer + m_offset + 12, sizeof(char) * static_cast(length)); + return length; + } - std::string getLegSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getLegSecurityIDSourceAsString(); + SecurityDefinitionResponse561 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 12, src, sizeof(char) * 256); + return *this; + } - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; - } + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getTextAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getTextAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } + } - return oss.str(); - } + return oss.str(); + } - SBE_NODISCARD static const char *LegSecurityIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 12; + std::size_t length = 0; - static SBE_CONSTEXPR std::uint16_t legSecurityIDId() SBE_NOEXCEPT { - return 602; - } + for (; length < 256 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSecurityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + return result; + } + #endif - SBE_NODISCARD bool legSecurityIDInActingVersion() SBE_NOEXCEPT { + #if __cplusplus >= 201703L + SecurityDefinitionResponse561 &putText(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.data(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionResponse561 &putText(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 256) + { + throw std::runtime_error("string too large for putText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 12, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 256; ++start) + { + m_buffer[m_offset + 12 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *FinancialInstrumentFullNameMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t financialInstrumentFullNameId() SBE_NOEXCEPT + { + return 2714; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t financialInstrumentFullNameSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool financialInstrumentFullNameInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legSecurityIDSinceVersion(); + return m_actingVersion >= financialInstrumentFullNameSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSecurityIDEncodingOffset() SBE_NOEXCEPT { - return 13; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t financialInstrumentFullNameEncodingOffset() SBE_NOEXCEPT + { + return 268; + } - static SBE_CONSTEXPR std::int32_t legSecurityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + static SBE_CONSTEXPR char financialInstrumentFullNameNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::int32_t legSecurityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR char financialInstrumentFullNameMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::int32_t legSecurityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR char financialInstrumentFullNameMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - legSecurityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t financialInstrumentFullNameEncodingLength() SBE_NOEXCEPT + { + return 35; + } - SBE_NODISCARD std::int32_t legSecurityID() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + static SBE_CONSTEXPR std::uint64_t financialInstrumentFullNameLength() SBE_NOEXCEPT + { + return 35; + } - NoLegs &legSecurityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::int32_t)); - return *this; - } + SBE_NODISCARD const char *financialInstrumentFullName() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - SBE_NODISCARD static const char * - LegSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *financialInstrumentFullName() SBE_NOEXCEPT + { + return m_buffer + m_offset + 268; + } - static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT { - return 624; - } + SBE_NODISCARD char financialInstrumentFullName(const std::uint64_t index) const + { + if (index >= 35) + { + throw std::runtime_error("index out of range for financialInstrumentFullName [E104]"); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSideSinceVersion() SBE_NOEXCEPT { - return 0; - } + char val; + std::memcpy(&val, m_buffer + m_offset + 268 + (index * 1), sizeof(char)); + return (val); + } - SBE_NODISCARD bool legSideInActingVersion() SBE_NOEXCEPT { + SecurityDefinitionResponse561 &financialInstrumentFullName(const std::uint64_t index, const char value) + { + if (index >= 35) + { + throw std::runtime_error("index out of range for financialInstrumentFullName [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 268 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getFinancialInstrumentFullName(char *const dst, const std::uint64_t length) const + { + if (length > 35) + { + throw std::runtime_error("length too large for getFinancialInstrumentFullName [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 268, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionResponse561 &putFinancialInstrumentFullName(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 268, src, sizeof(char) * 35); + return *this; + } + + SBE_NODISCARD std::string getFinancialInstrumentFullNameAsString() const + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; + + for (; length < 35 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getFinancialInstrumentFullNameAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getFinancialInstrumentFullNameAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getFinancialInstrumentFullNameAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 268; + std::size_t length = 0; + + for (; length < 35 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionResponse561 &putFinancialInstrumentFullName(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 35) + { + throw std::runtime_error("string too large for putFinancialInstrumentFullName [E106]"); + } + + std::memcpy(m_buffer + m_offset + 268, str.data(), srcLength); + for (std::size_t start = srcLength; start < 35; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionResponse561 &putFinancialInstrumentFullName(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 35) + { + throw std::runtime_error("string too large for putFinancialInstrumentFullName [E106]"); + } + + std::memcpy(m_buffer + m_offset + 268, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 35; ++start) + { + m_buffer[m_offset + 268 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SenderIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t senderIDId() SBE_NOEXCEPT + { + return 5392; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t senderIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool senderIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legSideSinceVersion(); + return m_actingVersion >= senderIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingOffset() SBE_NOEXCEPT { - return 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t senderIDEncodingOffset() SBE_NOEXCEPT + { + return 303; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR char senderIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - SBE_NODISCARD SideReq::Value legSide() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); - return SideReq::get((val)); - } + static SBE_CONSTEXPR char senderIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - NoLegs &legSide(const SideReq::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); - return *this; - } + static SBE_CONSTEXPR char senderIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - SBE_NODISCARD static const char * - LegRatioQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::size_t senderIDEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint16_t legRatioQtyId() SBE_NOEXCEPT { - return 623; - } + static SBE_CONSTEXPR std::uint64_t senderIDLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legRatioQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD const char *senderID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 303; + } - SBE_NODISCARD bool legRatioQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD char *senderID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 303; + } + + SBE_NODISCARD char senderID(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 303 + (index * 1), sizeof(char)); + return (val); + } + + SecurityDefinitionResponse561 &senderID(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for senderID [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 303 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getSenderID(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSenderID [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 303, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionResponse561 &putSenderID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 303, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getSenderIDAsString() const + { + const char *buffer = m_buffer + m_offset + 303; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSenderIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSenderIDAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSenderIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 303; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionResponse561 &putSenderID(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 303, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 303 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionResponse561 &putSenderID(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSenderID [E106]"); + } + + std::memcpy(m_buffer + m_offset + 303, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 303 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t symbolId() SBE_NOEXCEPT + { + return 55; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t symbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legRatioQtySinceVersion(); + return m_actingVersion >= symbolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legRatioQtyEncodingOffset() SBE_NOEXCEPT { - return 18; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t symbolEncodingOffset() SBE_NOEXCEPT + { + return 323; + } - static SBE_CONSTEXPR std::uint8_t legRatioQtyNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t legRatioQtyMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR std::uint8_t legRatioQtyMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - legRatioQtyEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } - SBE_NODISCARD std::uint8_t legRatioQty() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); - return (val); - } + static SBE_CONSTEXPR std::uint64_t symbolLength() SBE_NOEXCEPT + { + return 20; + } - NoLegs &legRatioQty(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 18, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD const char *symbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 323; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoLegs writer) { - builder << '{'; - builder << R"("LegPrice": )"; - builder << writer.legPrice(); + SBE_NODISCARD char *symbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 323; + } - builder << ", "; - builder << R"("LegOptionDelta": )"; - builder << writer.legOptionDelta(); + SBE_NODISCARD char symbol(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for symbol [E104]"); + } - builder << ", "; - builder << R"("LegSecurityID": )"; - builder << +writer.legSecurityID(); + char val; + std::memcpy(&val, m_buffer + m_offset + 323 + (index * 1), sizeof(char)); + return (val); + } - builder << ", "; - builder << R"("LegSide": )"; - builder << '"' << writer.legSide() << '"'; + SecurityDefinitionResponse561 &symbol(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for symbol [E105]"); + } - builder << ", "; - builder << R"("LegRatioQty": )"; - builder << +writer.legRatioQty(); + char val = (value); + std::memcpy(m_buffer + m_offset + 323 + (index * 1), &val, sizeof(char)); + return *this; + } - builder << '}'; + std::uint64_t getSymbol(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getSymbol [E106]"); + } - return builder; - } + std::memcpy(dst, m_buffer + m_offset + 323, sizeof(char) * static_cast(length)); + return length; + } - void skip() {} + SecurityDefinitionResponse561 &putSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 323, src, sizeof(char) * 20); + return *this; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + SBE_NODISCARD std::string getSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 323; + std::size_t length = 0; - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSymbolAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 323; + std::size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionResponse561 &putSymbol(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 323, str.data(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 323 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionResponse561 &putSymbol(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 323, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 323 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *PartyDetailsListReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t partyDetailsListReqIDId() SBE_NOEXCEPT + { + return 1505; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool partyDetailsListReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= partyDetailsListReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingOffset() SBE_NOEXCEPT + { + return 343; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t partyDetailsListReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t partyDetailsListReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t partyDetailsListReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 343, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + SecurityDefinitionResponse561 &partyDetailsListReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 343, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecurityReqIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityReqIDId() SBE_NOEXCEPT + { + return 320; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityReqIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityReqIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityReqIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityReqIDEncodingOffset() SBE_NOEXCEPT + { + return 351; + } + + static SBE_CONSTEXPR std::uint64_t securityReqIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t securityReqIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t securityReqIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t securityReqIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t securityReqID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 351, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + SecurityDefinitionResponse561 &securityReqID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 351, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecurityResponseIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityResponseIDId() SBE_NOEXCEPT + { + return 322; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityResponseIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityResponseIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityResponseIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityResponseIDEncodingOffset() SBE_NOEXCEPT + { + return 359; + } + + static SBE_CONSTEXPR std::uint64_t securityResponseIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t securityResponseIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t securityResponseIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t securityResponseIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t securityResponseID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 359, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + SecurityDefinitionResponse561 &securityResponseID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 359, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SendingTimeEpochMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sendingTimeEpochId() SBE_NOEXCEPT + { + return 5297; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sendingTimeEpochSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sendingTimeEpochInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sendingTimeEpochSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingOffset() SBE_NOEXCEPT + { + return 367; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t sendingTimeEpochMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t sendingTimeEpochEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t sendingTimeEpoch() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 367, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + SecurityDefinitionResponse561 &sendingTimeEpoch(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 367, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityGroupId() SBE_NOEXCEPT + { + return 1151; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityGroupSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityGroupInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityGroupSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 375; + } + + static SBE_CONSTEXPR char securityGroupNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char securityGroupMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char securityGroupMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t securityGroupEncodingLength() SBE_NOEXCEPT + { + return 6; + } + + static SBE_CONSTEXPR std::uint64_t securityGroupLength() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 375; + } + + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 375; + } + + SBE_NODISCARD char securityGroup(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 375 + (index * 1), sizeof(char)); + return (val); + } + + SecurityDefinitionResponse561 &securityGroup(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityGroup [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 375 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getSecurityGroup(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getSecurityGroup [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 375, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionResponse561 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 375, src, sizeof(char) * 6); + return *this; + } + + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 375; + std::size_t length = 0; + + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSecurityGroupAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityGroupAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 375; + std::size_t length = 0; + + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionResponse561 &putSecurityGroup(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } + + std::memcpy(m_buffer + m_offset + 375, str.data(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 375 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionResponse561 &putSecurityGroup(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityGroup [E106]"); + } + + std::memcpy(m_buffer + m_offset + 375, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 375 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityTypeId() SBE_NOEXCEPT + { + return 167; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTypeEncodingOffset() SBE_NOEXCEPT + { + return 381; + } + + static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char securityTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t securityTypeEncodingLength() SBE_NOEXCEPT + { + return 6; + } + + static SBE_CONSTEXPR std::uint64_t securityTypeLength() SBE_NOEXCEPT + { + return 6; + } + + SBE_NODISCARD const char *securityType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 381; + } + + SBE_NODISCARD char *securityType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 381; + } + + SBE_NODISCARD char securityType(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityType [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 381 + (index * 1), sizeof(char)); + return (val); + } + + SecurityDefinitionResponse561 &securityType(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for securityType [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 381 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getSecurityType(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getSecurityType [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 381, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionResponse561 &putSecurityType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 381, src, sizeof(char) * 6); + return *this; + } + + SBE_NODISCARD std::string getSecurityTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 381; + std::size_t length = 0; + + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getSecurityTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 381; + std::size_t length = 0; + + for (; length < 6 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionResponse561 &putSecurityType(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 381, str.data(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 381 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionResponse561 &putSecurityType(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putSecurityType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 381, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 381 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *LocationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t locationId() SBE_NOEXCEPT + { + return 9537; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t locationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool locationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= locationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t locationEncodingOffset() SBE_NOEXCEPT + { + return 387; + } + + static SBE_CONSTEXPR char locationNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char locationMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char locationMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t locationEncodingLength() SBE_NOEXCEPT + { + return 5; + } + + static SBE_CONSTEXPR std::uint64_t locationLength() SBE_NOEXCEPT + { + return 5; + } + + SBE_NODISCARD const char *location() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 387; + } + + SBE_NODISCARD char *location() SBE_NOEXCEPT + { + return m_buffer + m_offset + 387; + } + + SBE_NODISCARD char location(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 387 + (index * 1), sizeof(char)); + return (val); + } + + SecurityDefinitionResponse561 &location(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for location [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 387 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getLocation(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getLocation [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 387, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionResponse561 &putLocation(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 387, src, sizeof(char) * 5); + return *this; + } + + SBE_NODISCARD std::string getLocationAsString() const + { + const char *buffer = m_buffer + m_offset + 387; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getLocationAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLocationAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getLocationAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 387; + std::size_t length = 0; + + for (; length < 5 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionResponse561 &putLocation(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 387, str.data(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 387 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionResponse561 &putLocation(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putLocation [E106]"); + } + + std::memcpy(m_buffer + m_offset + 387, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 387 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDId() SBE_NOEXCEPT + { + return 48; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 392; + } + + static SBE_CONSTEXPR std::int32_t securityIDNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t securityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t securityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t securityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 392, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + SecurityDefinitionResponse561 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 392, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t currencyId() SBE_NOEXCEPT + { + return 15; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t currencySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= currencySinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t currencyEncodingOffset() SBE_NOEXCEPT + { + return 396; + } + + static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char currencyMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t currencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t currencyLength() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD const char *currency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 396; + } + + SBE_NODISCARD char *currency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 396; + } + + SBE_NODISCARD char currency(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for currency [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 396 + (index * 1), sizeof(char)); + return (val); + } + + SecurityDefinitionResponse561 ¤cy(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for currency [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 396 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getCurrency(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getCurrency [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 396, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionResponse561 &putCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 396, src, sizeof(char) * 3); + return *this; + } + + SecurityDefinitionResponse561 &putCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 396, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 397, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 398, &val2, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 396; + std::size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCurrencyAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 396; + std::size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionResponse561 &putCurrency(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putCurrency [E106]"); + } + + std::memcpy(m_buffer + m_offset + 396, str.data(), srcLength); + for (std::size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 396 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionResponse561 &putCurrency(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putCurrency [E106]"); + } + + std::memcpy(m_buffer + m_offset + 396, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 396 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityIDSourceId() SBE_NOEXCEPT + { + return 22; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityIDSourceSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 399; + } + + static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char securityIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t securityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *securityIDSource() const + { + static const std::uint8_t securityIDSourceValues[] = { 56, 0 }; + + return (const char *)securityIDSourceValues; + } + + SBE_NODISCARD char securityIDSource(const std::uint64_t index) const + { + static const std::uint8_t securityIDSourceValues[] = { 56, 0 }; + + return (char)securityIDSourceValues[index]; + } + + std::uint64_t getSecurityIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t securityIDSourceValues[] = { 56 }; + std::uint64_t bytesToCopy = length < sizeof(securityIDSourceValues) ? length : sizeof(securityIDSourceValues); + + std::memcpy(dst, securityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getSecurityIDSourceAsString() const + { + static const std::uint8_t SecurityIDSourceValues[] = { 56 }; + + return std::string((const char *)SecurityIDSourceValues, 1); + } + + std::string getSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityIDSourceAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *MaturityMonthYearMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "MonthYear"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t maturityMonthYearId() SBE_NOEXCEPT + { + return 200; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maturityMonthYearSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= maturityMonthYearSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maturityMonthYearEncodingOffset() SBE_NOEXCEPT + { + return 399; + } + +private: + MaturityMonthYear m_maturityMonthYear; + +public: + SBE_NODISCARD MaturityMonthYear &maturityMonthYear() + { + m_maturityMonthYear.wrap(m_buffer, m_offset + 399, m_actingVersion, m_bufferLength); + return m_maturityMonthYear; + } + + SBE_NODISCARD static const char *DelayDurationMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t delayDurationId() SBE_NOEXCEPT + { + return 5904; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t delayDurationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool delayDurationInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= delayDurationSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t delayDurationEncodingOffset() SBE_NOEXCEPT + { + return 404; + } + + static SBE_CONSTEXPR std::uint16_t delayDurationNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t delayDurationMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t delayDurationMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t delayDurationEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t delayDuration() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 404, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + SecurityDefinitionResponse561 &delayDuration(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 404, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *StartDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t startDateId() SBE_NOEXCEPT + { + return 916; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t startDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool startDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= startDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t startDateEncodingOffset() SBE_NOEXCEPT + { + return 406; + } + + static SBE_CONSTEXPR std::uint16_t startDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t startDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t startDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t startDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t startDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 406, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + SecurityDefinitionResponse561 &startDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 406, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *EndDateMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t endDateId() SBE_NOEXCEPT + { + return 917; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t endDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool endDateInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= endDateSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t endDateEncodingOffset() SBE_NOEXCEPT + { + return 408; + } + + static SBE_CONSTEXPR std::uint16_t endDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t endDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t endDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t endDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t endDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 408, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + SecurityDefinitionResponse561 &endDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 408, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *MaxNoOfSubstitutionsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t maxNoOfSubstitutionsId() SBE_NOEXCEPT + { + return 37715; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxNoOfSubstitutionsSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool maxNoOfSubstitutionsInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= maxNoOfSubstitutionsSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxNoOfSubstitutionsEncodingOffset() SBE_NOEXCEPT + { + return 410; + } + + static SBE_CONSTEXPR std::uint8_t maxNoOfSubstitutionsNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t maxNoOfSubstitutionsMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t maxNoOfSubstitutionsMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t maxNoOfSubstitutionsEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t maxNoOfSubstitutions() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 410, sizeof(std::uint8_t)); + return (val); + } + + SecurityDefinitionResponse561 &maxNoOfSubstitutions(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 410, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SourceRepoIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t sourceRepoIDId() SBE_NOEXCEPT + { + return 5677; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sourceRepoIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool sourceRepoIDInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= sourceRepoIDSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t sourceRepoIDEncodingOffset() SBE_NOEXCEPT + { + return 411; + } + + static SBE_CONSTEXPR std::int32_t sourceRepoIDNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t sourceRepoIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t sourceRepoIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t sourceRepoIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t sourceRepoID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 411, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + SecurityDefinitionResponse561 &sourceRepoID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 411, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *TerminationTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t terminationTypeId() SBE_NOEXCEPT + { + return 788; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t terminationTypeSinceVersion() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD bool terminationTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= terminationTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t terminationTypeEncodingOffset() SBE_NOEXCEPT + { + return 415; + } + + static SBE_CONSTEXPR char terminationTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char terminationTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char terminationTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t terminationTypeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t terminationTypeLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD const char *terminationType() const SBE_NOEXCEPT + { + if (m_actingVersion < 3) + { + return nullptr; + } + + return m_buffer + m_offset + 415; + } + + SBE_NODISCARD char *terminationType() SBE_NOEXCEPT + { + if (m_actingVersion < 3) + { + return nullptr; + } + + return m_buffer + m_offset + 415; + } + + SBE_NODISCARD char terminationType(const std::uint64_t index) const + { + if (index >= 8) + { + throw std::runtime_error("index out of range for terminationType [E104]"); + } + + if (m_actingVersion < 3) + { + return static_cast(0); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 415 + (index * 1), sizeof(char)); + return (val); + } + + SecurityDefinitionResponse561 &terminationType(const std::uint64_t index, const char value) + { + if (index >= 8) + { + throw std::runtime_error("index out of range for terminationType [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 415 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getTerminationType(char *const dst, const std::uint64_t length) const + { + if (length > 8) + { + throw std::runtime_error("length too large for getTerminationType [E106]"); + } + + if (m_actingVersion < 3) + { + return 0; + } + + std::memcpy(dst, m_buffer + m_offset + 415, sizeof(char) * static_cast(length)); + return length; + } + + SecurityDefinitionResponse561 &putTerminationType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 415, src, sizeof(char) * 8); + return *this; + } + + SBE_NODISCARD std::string getTerminationTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 415; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getTerminationTypeAsJsonEscapedString() + { + if (m_actingVersion < 3) + { + return std::string(""); + } + + std::ostringstream oss; + std::string s = getTerminationTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTerminationTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 415; + std::size_t length = 0; + + for (; length < 8 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + SecurityDefinitionResponse561 &putTerminationType(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putTerminationType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 415, str.data(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 415 + start] = 0; + } + + return *this; + } + #else + SecurityDefinitionResponse561 &putTerminationType(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 8) + { + throw std::runtime_error("string too large for putTerminationType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 415, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 8; ++start) + { + m_buffer[m_offset + 415 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *SecurityResponseTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t securityResponseTypeId() SBE_NOEXCEPT + { + return 323; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityResponseTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool securityResponseTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= securityResponseTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityResponseTypeEncodingOffset() SBE_NOEXCEPT + { + return 423; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityResponseTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t securityResponseTypeRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 423, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SecRspTyp::Value securityResponseType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 423, sizeof(std::uint8_t)); + return SecRspTyp::get((val)); + } + + SecurityDefinitionResponse561 &securityResponseType(const SecRspTyp::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 423, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *UserDefinedInstrumentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t userDefinedInstrumentId() SBE_NOEXCEPT + { + return 9779; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t userDefinedInstrumentSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= userDefinedInstrumentSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT + { + return 424; + } + + static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t userDefinedInstrumentLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *userDefinedInstrument() const + { + static const std::uint8_t userDefinedInstrumentValues[] = { 89, 0 }; + + return (const char *)userDefinedInstrumentValues; + } + + SBE_NODISCARD char userDefinedInstrument(const std::uint64_t index) const + { + static const std::uint8_t userDefinedInstrumentValues[] = { 89, 0 }; + + return (char)userDefinedInstrumentValues[index]; + } + + std::uint64_t getUserDefinedInstrument(char *dst, const std::uint64_t length) const + { + static std::uint8_t userDefinedInstrumentValues[] = { 89 }; + std::uint64_t bytesToCopy = length < sizeof(userDefinedInstrumentValues) ? length : sizeof(userDefinedInstrumentValues); + + std::memcpy(dst, userDefinedInstrumentValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getUserDefinedInstrumentAsString() const + { + static const std::uint8_t UserDefinedInstrumentValues[] = { 89 }; + + return std::string((const char *)UserDefinedInstrumentValues, 1); + } + + std::string getUserDefinedInstrumentAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUserDefinedInstrumentAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *ExpirationCycleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t expirationCycleId() SBE_NOEXCEPT + { + return 827; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t expirationCycleSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool expirationCycleInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= expirationCycleSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expirationCycleEncodingOffset() SBE_NOEXCEPT + { + return 424; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t expirationCycleEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t expirationCycleRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 424, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ExpCycle::Value expirationCycle() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 424, sizeof(std::uint8_t)); + return ExpCycle::get((val)); + } + + SecurityDefinitionResponse561 &expirationCycle(const ExpCycle::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 424, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *ManualOrderIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t manualOrderIndicatorId() SBE_NOEXCEPT + { + return 1028; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t manualOrderIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool manualOrderIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= manualOrderIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 425; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t manualOrderIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t manualOrderIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 425, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD ManualOrdIndReq::Value manualOrderIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 425, sizeof(std::uint8_t)); + return ManualOrdIndReq::get((val)); + } + + SecurityDefinitionResponse561 &manualOrderIndicator(const ManualOrdIndReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 425, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= splitMsgSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 426; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 426, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 426, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } + + SecurityDefinitionResponse561 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 426, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *AutoQuoteRequestMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t autoQuoteRequestId() SBE_NOEXCEPT + { + return 9776; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t autoQuoteRequestSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool autoQuoteRequestInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= autoQuoteRequestSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t autoQuoteRequestEncodingOffset() SBE_NOEXCEPT + { + return 427; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t autoQuoteRequestEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t autoQuoteRequestRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 427, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value autoQuoteRequest() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 427, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + SecurityDefinitionResponse561 &autoQuoteRequest(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 427, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *PossRetransFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t possRetransFlagId() SBE_NOEXCEPT + { + return 9765; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t possRetransFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool possRetransFlagInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= possRetransFlagSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingOffset() SBE_NOEXCEPT + { + return 428; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t possRetransFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t possRetransFlagRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 428, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD BooleanFlag::Value possRetransFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 428, sizeof(std::uint8_t)); + return BooleanFlag::get((val)); + } + + SecurityDefinitionResponse561 &possRetransFlag(const BooleanFlag::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 428, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *BrokenDateTermTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t brokenDateTermTypeId() SBE_NOEXCEPT + { + return 6651; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t brokenDateTermTypeSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool brokenDateTermTypeInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= brokenDateTermTypeSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t brokenDateTermTypeEncodingOffset() SBE_NOEXCEPT + { + return 429; + } + + static SBE_CONSTEXPR std::uint8_t brokenDateTermTypeNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t brokenDateTermTypeMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t brokenDateTermTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t brokenDateTermTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t brokenDateTermType() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return static_cast(255); + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 429, sizeof(std::uint8_t)); + return (val); + } + + SecurityDefinitionResponse561 &brokenDateTermType(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 429, &val, sizeof(std::uint8_t)); + return *this; + } + + class NoLegs + { + private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; + + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } + + public: + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); + } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(19)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 19; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 19; + } + + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } + + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } + + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoLegs &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *LegPriceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legPriceId() SBE_NOEXCEPT + { + return 566; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legPriceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legPriceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legPriceEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL9 m_legPrice; + +public: + SBE_NODISCARD PRICENULL9 &legPrice() + { + m_legPrice.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_legPrice; + } + + SBE_NODISCARD static const char *LegOptionDeltaMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "float"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legOptionDeltaId() SBE_NOEXCEPT + { + return 1017; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legOptionDeltaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legOptionDeltaInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legOptionDeltaSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legOptionDeltaEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + +private: + Decimal32NULL m_legOptionDelta; + +public: + SBE_NODISCARD Decimal32NULL &legOptionDelta() + { + m_legOptionDelta.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_legOptionDelta; + } + + SBE_NODISCARD static const char *LegSecurityIDSourceMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "char"; + case MetaAttribute::PRESENCE: return "constant"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legSecurityIDSourceId() SBE_NOEXCEPT + { + return 603; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSecurityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legSecurityIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSecurityIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSecurityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 13; + } + + static SBE_CONSTEXPR char legSecurityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char legSecurityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char legSecurityIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t legSecurityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t legSecurityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *legSecurityIDSource() const + { + static const std::uint8_t legSecurityIDSourceValues[] = { 56, 0 }; + + return (const char *)legSecurityIDSourceValues; + } + + SBE_NODISCARD char legSecurityIDSource(const std::uint64_t index) const + { + static const std::uint8_t legSecurityIDSourceValues[] = { 56, 0 }; + + return (char)legSecurityIDSourceValues[index]; + } + + std::uint64_t getLegSecurityIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t legSecurityIDSourceValues[] = { 56 }; + std::uint64_t bytesToCopy = length < sizeof(legSecurityIDSourceValues) ? length : sizeof(legSecurityIDSourceValues); + + std::memcpy(dst, legSecurityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getLegSecurityIDSourceAsString() const + { + static const std::uint8_t LegSecurityIDSourceValues[] = { 56 }; + + return std::string((const char *)LegSecurityIDSourceValues, 1); + } + + std::string getLegSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getLegSecurityIDSourceAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + SBE_NODISCARD static const char *LegSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legSecurityIDId() SBE_NOEXCEPT + { + return 602; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSecurityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legSecurityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSecurityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSecurityIDEncodingOffset() SBE_NOEXCEPT + { + return 13; + } + + static SBE_CONSTEXPR std::int32_t legSecurityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t legSecurityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t legSecurityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t legSecurityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t legSecurityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoLegs &legSecurityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *LegSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT + { + return 624; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legSideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legSideInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legSideSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t legSideRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); + return (val); + } + + SBE_NODISCARD SideReq::Value legSide() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); + return SideReq::get((val)); + } + + NoLegs &legSide(const SideReq::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *LegRatioQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t legRatioQtyId() SBE_NOEXCEPT + { + return 623; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t legRatioQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool legRatioQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= legRatioQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legRatioQtyEncodingOffset() SBE_NOEXCEPT + { + return 18; + } + + static SBE_CONSTEXPR std::uint8_t legRatioQtyNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t legRatioQtyMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t legRatioQtyMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t legRatioQtyEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t legRatioQty() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return (val); + } + + NoLegs &legRatioQty(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 18, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoLegs writer) + { + builder << '{'; + builder << R"("LegPrice": )"; + builder << writer.legPrice(); + + builder << ", "; + builder << R"("LegOptionDelta": )"; + builder << writer.legOptionDelta(); + + builder << ", "; + builder << R"("LegSecurityID": )"; + builder << +writer.legSecurityID(); + + builder << ", "; + builder << R"("LegSide": )"; + builder << '"' << writer.legSide() << '"'; + + builder << ", "; + builder << R"("LegRatioQty": )"; + builder << +writer.legRatioQty(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } - }; + } + }; - private: - NoLegs m_noLegs; +private: + NoLegs m_noLegs; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT { - return 555; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT + { + return 555; + } - SBE_NODISCARD inline NoLegs &noLegs() { - m_noLegs.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + SBE_NODISCARD inline NoLegs &noLegs() + { + m_noLegs.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLegs; + } - NoLegs &noLegsCount(const std::uint8_t count) { - m_noLegs.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + NoLegs &noLegsCount(const std::uint8_t count) + { + m_noLegs.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLegs; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLegsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLegsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noLegsSinceVersion(); + return m_actingVersion >= noLegsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - SecurityDefinitionResponse561 _writer) { - SecurityDefinitionResponse561 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "SecurityDefinitionResponse561", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + class NoBrokenDates + { + private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_initialPosition = 0; + std::uint64_t *m_positionPtr = nullptr; + std::uint64_t m_blockLength = 0; + std::uint64_t m_count = 0; + std::uint64_t m_index = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_actingVersion = 0; - builder << R"("SeqNum": )"; - builder << +writer.seqNum(); + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + public: + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + m_buffer = buffer; + m_bufferLength = bufferLength; + m_blockLength = dimensions.blockLength(); + m_count = dimensions.numInGroup(); + m_index = 0; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("FinancialInstrumentFullName": )"; - builder - << '"' - << writer.getFinancialInstrumentFullNameAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("SenderID": )"; - builder << '"' << writer.getSenderIDAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("Symbol": )"; - builder << '"' << writer.getSymbolAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("PartyDetailsListReqID": )"; - builder << +writer.partyDetailsListReqID(); - - builder << ", "; - builder << R"("SecurityReqID": )"; - builder << +writer.securityReqID(); - - builder << ", "; - builder << R"("SecurityResponseID": )"; - builder << +writer.securityResponseID(); - - builder << ", "; - builder << R"("SendingTimeEpoch": )"; - builder << +writer.sendingTimeEpoch(); - - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("SecurityType": )"; - builder << '"' << writer.getSecurityTypeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("Location": )"; - builder << '"' << writer.getLocationAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("Currency": )"; - builder << '"' << writer.getCurrencyAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("MaturityMonthYear": )"; - builder << writer.maturityMonthYear(); - - builder << ", "; - builder << R"("DelayDuration": )"; - builder << +writer.delayDuration(); - - builder << ", "; - builder << R"("StartDate": )"; - builder << +writer.startDate(); - - builder << ", "; - builder << R"("EndDate": )"; - builder << +writer.endDate(); - - builder << ", "; - builder << R"("MaxNoOfSubstitutions": )"; - builder << +writer.maxNoOfSubstitutions(); - - builder << ", "; - builder << R"("SourceRepoID": )"; - builder << +writer.sourceRepoID(); - - builder << ", "; - builder << R"("TerminationType": )"; - builder << '"' << writer.getTerminationTypeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("SecurityResponseType": )"; - builder << '"' << writer.securityResponseType() << '"'; - - builder << ", "; - builder << R"("ExpirationCycle": )"; - builder << '"' << writer.expirationCycle() << '"'; - - builder << ", "; - builder << R"("ManualOrderIndicator": )"; - builder << '"' << writer.manualOrderIndicator() << '"'; - - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; - - builder << ", "; - builder << R"("AutoQuoteRequest": )"; - builder << '"' << writer.autoQuoteRequest() << '"'; - - builder << ", "; - builder << R"("PossRetransFlag": )"; - builder << '"' << writer.possRetransFlag() << '"'; - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLegs": [)"; - writer.noLegs().forEach([&](NoLegs &noLegs) { - if (atLeastOne) { - builder << ", "; + inline void wrapForEncode( + char *buffer, + const std::uint8_t count, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wtype-limits" + #endif + if (count > 254) + { + throw std::runtime_error("count outside of allowed range [E110]"); } - atLeastOne = true; - builder << noLegs; - }); - builder << ']'; - } + #if defined(__GNUG__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + m_buffer = buffer; + m_bufferLength = bufferLength; + GroupSize dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(16)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 16; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - return builder; - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 16; + } - void skip() { - noLegs().forEach([](NoLegs e) { e.skip(); }); - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return false; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t - computeLength(std::size_t NoLegsLength = 0) { + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } + + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } + + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoBrokenDates &next() + { + if (m_index >= m_count) + { + throw std::runtime_error("index >= count [E108]"); + } + m_offset = *m_positionPtr; + if (SBE_BOUNDS_CHECK_EXPECT(((m_offset + m_blockLength) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for next group index [E108]"); + } + *m_positionPtr = m_offset + m_blockLength; + ++m_index; + + return *this; + } + + inline std::uint64_t resetCountToIndex() + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } + + template inline void forEach(Func &&func) + { + while (hasNext()) + { + next(); + func(*this); + } + } + + + SBE_NODISCARD static const char *BrokenDateGUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t brokenDateGUIDId() SBE_NOEXCEPT + { + return 39031; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t brokenDateGUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool brokenDateGUIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= brokenDateGUIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t brokenDateGUIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t brokenDateGUIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t brokenDateGUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t brokenDateGUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t brokenDateGUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t brokenDateGUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoBrokenDates &brokenDateGUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } + + SBE_NODISCARD static const char *BrokenDateSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t brokenDateSecurityIDId() SBE_NOEXCEPT + { + return 39027; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t brokenDateSecurityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool brokenDateSecurityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= brokenDateSecurityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t brokenDateSecurityIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::int32_t brokenDateSecurityIDNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t brokenDateSecurityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t brokenDateSecurityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t brokenDateSecurityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t brokenDateSecurityID() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoBrokenDates &brokenDateSecurityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *BrokenDateStartMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t brokenDateStartId() SBE_NOEXCEPT + { + return 6748; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t brokenDateStartSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool brokenDateStartInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= brokenDateStartSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t brokenDateStartEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR std::uint16_t brokenDateStartNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t brokenDateStartMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t brokenDateStartMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t brokenDateStartEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t brokenDateStart() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoBrokenDates &brokenDateStart(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 12, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *BrokenDateEndMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "LocalMktDate"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t brokenDateEndId() SBE_NOEXCEPT + { + return 6741; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t brokenDateEndSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool brokenDateEndInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= brokenDateEndSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t brokenDateEndEncodingOffset() SBE_NOEXCEPT + { + return 14; + } + + static SBE_CONSTEXPR std::uint16_t brokenDateEndNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t brokenDateEndMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t brokenDateEndMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t brokenDateEndEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t brokenDateEnd() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoBrokenDates &brokenDateEnd(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint16_t)); + return *this; + } + + template + friend std::basic_ostream & operator << ( + std::basic_ostream &builder, NoBrokenDates writer) + { + builder << '{'; + builder << R"("BrokenDateGUID": )"; + builder << +writer.brokenDateGUID(); + + builder << ", "; + builder << R"("BrokenDateSecurityID": )"; + builder << +writer.brokenDateSecurityID(); + + builder << ", "; + builder << R"("BrokenDateStart": )"; + builder << +writer.brokenDateStart(); + + builder << ", "; + builder << R"("BrokenDateEnd": )"; + builder << +writer.brokenDateEnd(); + + builder << '}'; + + return builder; + } + + void skip() + { + } + + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } + + SBE_NODISCARD static std::size_t computeLength() + { #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - length += NoLegs::sbeHeaderSize(); - if (NoLegsLength > 254) { - throw std::runtime_error( - "NoLegsLength outside of allowed range [E110]"); - } - length += NoLegsLength * NoLegs::sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } + } + }; + +private: + NoBrokenDates m_noBrokenDates; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoBrokenDatesId() SBE_NOEXCEPT + { + return 39026; + } + + SBE_NODISCARD inline NoBrokenDates &noBrokenDates() + { + m_noBrokenDates.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noBrokenDates; + } + + NoBrokenDates &noBrokenDatesCount(const std::uint8_t count) + { + m_noBrokenDates.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noBrokenDates; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noBrokenDatesSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool noBrokenDatesInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noBrokenDatesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, SecurityDefinitionResponse561 _writer) +{ + SecurityDefinitionResponse561 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); + + builder << '{'; + builder << R"("Name": "SecurityDefinitionResponse561", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("SeqNum": )"; + builder << +writer.seqNum(); + + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); + + builder << ", "; + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("FinancialInstrumentFullName": )"; + builder << '"' << + writer.getFinancialInstrumentFullNameAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SenderID": )"; + builder << '"' << + writer.getSenderIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Symbol": )"; + builder << '"' << + writer.getSymbolAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PartyDetailsListReqID": )"; + builder << +writer.partyDetailsListReqID(); + + builder << ", "; + builder << R"("SecurityReqID": )"; + builder << +writer.securityReqID(); + + builder << ", "; + builder << R"("SecurityResponseID": )"; + builder << +writer.securityResponseID(); + + builder << ", "; + builder << R"("SendingTimeEpoch": )"; + builder << +writer.sendingTimeEpoch(); + + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityType": )"; + builder << '"' << + writer.getSecurityTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Location": )"; + builder << '"' << + writer.getLocationAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("Currency": )"; + builder << '"' << + writer.getCurrencyAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MaturityMonthYear": )"; + builder << writer.maturityMonthYear(); + + builder << ", "; + builder << R"("DelayDuration": )"; + builder << +writer.delayDuration(); + + builder << ", "; + builder << R"("StartDate": )"; + builder << +writer.startDate(); + + builder << ", "; + builder << R"("EndDate": )"; + builder << +writer.endDate(); + + builder << ", "; + builder << R"("MaxNoOfSubstitutions": )"; + builder << +writer.maxNoOfSubstitutions(); + + builder << ", "; + builder << R"("SourceRepoID": )"; + builder << +writer.sourceRepoID(); + + builder << ", "; + builder << R"("TerminationType": )"; + builder << '"' << + writer.getTerminationTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityResponseType": )"; + builder << '"' << writer.securityResponseType() << '"'; + + builder << ", "; + builder << R"("ExpirationCycle": )"; + builder << '"' << writer.expirationCycle() << '"'; + + builder << ", "; + builder << R"("ManualOrderIndicator": )"; + builder << '"' << writer.manualOrderIndicator() << '"'; + + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; + + builder << ", "; + builder << R"("AutoQuoteRequest": )"; + builder << '"' << writer.autoQuoteRequest() << '"'; + + builder << ", "; + builder << R"("PossRetransFlag": )"; + builder << '"' << writer.possRetransFlag() << '"'; + + builder << ", "; + builder << R"("BrokenDateTermType": )"; + builder << +writer.brokenDateTermType(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLegs": [)"; + writer.noLegs().forEach( + [&](NoLegs &noLegs) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noLegs; + }); + builder << ']'; + } + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoBrokenDates": [)"; + writer.noBrokenDates().forEach( + [&](NoBrokenDates &noBrokenDates) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noBrokenDates; + }); + builder << ']'; + } + + builder << '}'; + + return builder; +} + +void skip() +{ + auto &noLegsGroup { noLegs() }; + while (noLegsGroup.hasNext()) + { + noLegsGroup.next().skip(); + } + auto &noBrokenDatesGroup { noBrokenDates() }; + while (noBrokenDatesGroup.hasNext()) + { + noBrokenDatesGroup.next().skip(); + } +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noLegsLength = 0, + std::size_t noBrokenDatesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoLegs::sbeHeaderSize(); + if (noLegsLength > 254LL) + { + throw std::runtime_error("noLegsLength outside of allowed range [E110]"); + } + length += noLegsLength *NoLegs::sbeBlockLength(); + + length += NoBrokenDates::sbeHeaderSize(); + if (noBrokenDatesLength > 254LL) + { + throw std::runtime_error("noBrokenDatesLength outside of allowed range [E110]"); + } + length += noBrokenDatesLength *NoBrokenDates::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/Sequence506.h b/src/lib/orderman/ilink3/generated/Sequence506.h index 1168cb298..3efcd7219 100644 --- a/src/lib/orderman/ilink3/generated/Sequence506.h +++ b/src/lib/orderman/ilink3/generated/Sequence506.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,510 +86,592 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class Sequence506 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class Sequence506 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(14); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(506); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - Sequence506() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - Sequence506( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - Sequence506(char *buffer, const std::uint64_t bufferLength) - : Sequence506( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + Sequence506() = default; - Sequence506( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : Sequence506( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + Sequence506( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)14; - } + Sequence506(char *buffer, const std::uint64_t bufferLength) : + Sequence506(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + Sequence506( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + Sequence506(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)506; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(14); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(506); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "Sequence"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - Sequence506 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = Sequence506( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "Sequence"; + } - Sequence506 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + Sequence506 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = Sequence506(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = Sequence506( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + Sequence506 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - Sequence506 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = Sequence506( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = Sequence506( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + Sequence506 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = Sequence506(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + Sequence506 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - Sequence506 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + Sequence506 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Sequence506 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); - return *this; - } + Sequence506 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *NextSeqNoMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t nextSeqNoId() SBE_NOEXCEPT { - return 39013; - } + static SBE_CONSTEXPR std::uint16_t nextSeqNoId() SBE_NOEXCEPT + { + return 39013; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - nextSeqNoSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t nextSeqNoSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool nextSeqNoInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool nextSeqNoInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= nextSeqNoSinceVersion(); + return m_actingVersion >= nextSeqNoSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - nextSeqNoEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t nextSeqNoEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t nextSeqNoMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t nextSeqNoEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t nextSeqNo() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t nextSeqNo() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - Sequence506 &nextSeqNo(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); - return *this; - } + Sequence506 &nextSeqNo(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 8, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *FaultToleranceIndicatorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT { - return 39010; - } + static SBE_CONSTEXPR std::uint16_t faultToleranceIndicatorId() SBE_NOEXCEPT + { + return 39010; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t faultToleranceIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool faultToleranceIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= faultToleranceIndicatorSinceVersion(); + return m_actingVersion >= faultToleranceIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t faultToleranceIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD FTI::Value faultToleranceIndicator() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::uint8_t)); - return FTI::get((val)); - } + SBE_NODISCARD std::uint8_t faultToleranceIndicatorRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::uint8_t)); + return (val); + } - Sequence506 &faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 12, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD FTI::Value faultToleranceIndicator() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::uint8_t)); + return FTI::get((val)); + } - SBE_NODISCARD static const char *KeepAliveIntervalLapsedMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + Sequence506 &faultToleranceIndicator(const FTI::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 12, &val, sizeof(std::uint8_t)); + return *this; + } - static SBE_CONSTEXPR std::uint16_t keepAliveIntervalLapsedId() SBE_NOEXCEPT { - return 39016; - } + SBE_NODISCARD static const char *KeepAliveIntervalLapsedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - keepAliveIntervalLapsedSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t keepAliveIntervalLapsedId() SBE_NOEXCEPT + { + return 39016; + } - SBE_NODISCARD bool keepAliveIntervalLapsedInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t keepAliveIntervalLapsedSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool keepAliveIntervalLapsedInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= keepAliveIntervalLapsedSinceVersion(); + return m_actingVersion >= keepAliveIntervalLapsedSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - keepAliveIntervalLapsedEncodingOffset() SBE_NOEXCEPT { - return 13; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t keepAliveIntervalLapsedEncodingOffset() SBE_NOEXCEPT + { + return 13; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - keepAliveIntervalLapsedEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t keepAliveIntervalLapsedEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD KeepAliveLapsed::Value - keepAliveIntervalLapsed() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint8_t)); - return KeepAliveLapsed::get((val)); - } + SBE_NODISCARD std::uint8_t keepAliveIntervalLapsedRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint8_t)); + return (val); + } - Sequence506 & - keepAliveIntervalLapsed(const KeepAliveLapsed::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD KeepAliveLapsed::Value keepAliveIntervalLapsed() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 13, sizeof(std::uint8_t)); + return KeepAliveLapsed::get((val)); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, Sequence506 _writer) { - Sequence506 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "Sequence506", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + Sequence506 &keepAliveIntervalLapsed(const KeepAliveLapsed::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 13, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("UUID": )"; - builder << +writer.uUID(); +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, Sequence506 _writer) +{ + Sequence506 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("NextSeqNo": )"; - builder << +writer.nextSeqNo(); + builder << '{'; + builder << R"("Name": "Sequence506", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("FaultToleranceIndicator": )"; - builder << '"' << writer.faultToleranceIndicator() << '"'; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("KeepAliveIntervalLapsed": )"; - builder << '"' << writer.keepAliveIntervalLapsed() << '"'; + builder << ", "; + builder << R"("NextSeqNo": )"; + builder << +writer.nextSeqNo(); - builder << '}'; + builder << ", "; + builder << R"("FaultToleranceIndicator": )"; + builder << '"' << writer.faultToleranceIndicator() << '"'; - return builder; - } + builder << ", "; + builder << R"("KeepAliveIntervalLapsed": )"; + builder << '"' << writer.keepAliveIntervalLapsed() << '"'; - void skip() {} + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/ShortSaleType.h b/src/lib/orderman/ilink3/generated/ShortSaleType.h index 22bb61167..5ec0be304 100644 --- a/src/lib/orderman/ilink3/generated/ShortSaleType.h +++ b/src/lib/orderman/ilink3/generated/ShortSaleType.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_SHORTSALETYPE_H_ #define _ILINKBINARY_SHORTSALETYPE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,57 +25,54 @@ namespace iLinkBinary { -class ShortSaleType { - public: - enum Value { - LongSell = (std::uint8_t)0, - ShortSaleWithNoExemptionSESH = (std::uint8_t)1, - ShortSaleWithExemptionSSEX = (std::uint8_t)2, - UndisclosedSellInformationNotAvailableUNDI = (std::uint8_t)3, - NULL_VALUE = (std::uint8_t)255 - }; +class ShortSaleType +{ +public: + enum Value + { + LongSell = static_cast(0), + ShortSaleWithNoExemptionSESH = static_cast(1), + ShortSaleWithExemptionSSEX = static_cast(2), + UndisclosedSellInformationNotAvailableUNDI = static_cast(3), + NULL_VALUE = static_cast(255) + }; - static ShortSaleType::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return LongSell; - case 1: - return ShortSaleWithNoExemptionSESH; - case 2: - return ShortSaleWithExemptionSSEX; - case 3: - return UndisclosedSellInformationNotAvailableUNDI; - case 255: - return NULL_VALUE; - } + static ShortSaleType::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return LongSell; + case static_cast(1): return ShortSaleWithNoExemptionSESH; + case static_cast(2): return ShortSaleWithExemptionSSEX; + case static_cast(3): return UndisclosedSellInformationNotAvailableUNDI; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum ShortSaleType [E103]"); - } + throw std::runtime_error("unknown value for enum ShortSaleType [E103]"); + } - static const char *c_str(const ShortSaleType::Value value) { - switch (value) { - case LongSell: - return "LongSell"; - case ShortSaleWithNoExemptionSESH: - return "ShortSaleWithNoExemptionSESH"; - case ShortSaleWithExemptionSSEX: - return "ShortSaleWithExemptionSSEX"; - case UndisclosedSellInformationNotAvailableUNDI: - return "UndisclosedSellInformationNotAvailableUNDI"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const ShortSaleType::Value value) + { + switch (value) + { + case LongSell: return "LongSell"; + case ShortSaleWithNoExemptionSESH: return "ShortSaleWithNoExemptionSESH"; + case ShortSaleWithExemptionSSEX: return "ShortSaleWithExemptionSSEX"; + case UndisclosedSellInformationNotAvailableUNDI: return "UndisclosedSellInformationNotAvailableUNDI"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum ShortSaleType [E103]:"); - } + throw std::runtime_error("unknown value for enum ShortSaleType [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, ShortSaleType::Value m) { - return os << ShortSaleType::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, ShortSaleType::Value m) + { + return os << ShortSaleType::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/SideNULL.h b/src/lib/orderman/ilink3/generated/SideNULL.h index 353b4ad99..f887796af 100644 --- a/src/lib/orderman/ilink3/generated/SideNULL.h +++ b/src/lib/orderman/ilink3/generated/SideNULL.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_SIDENULL_H_ #define _ILINKBINARY_SIDENULL_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,48 @@ namespace iLinkBinary { -class SideNULL { - public: - enum Value { - Buy = (std::uint8_t)1, - Sell = (std::uint8_t)2, - NULL_VALUE = (std::uint8_t)255 - }; +class SideNULL +{ +public: + enum Value + { + Buy = static_cast(1), + Sell = static_cast(2), + NULL_VALUE = static_cast(255) + }; - static SideNULL::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return Buy; - case 2: - return Sell; - case 255: - return NULL_VALUE; - } + static SideNULL::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return Buy; + case static_cast(2): return Sell; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum SideNULL [E103]"); - } + throw std::runtime_error("unknown value for enum SideNULL [E103]"); + } - static const char *c_str(const SideNULL::Value value) { - switch (value) { - case Buy: - return "Buy"; - case Sell: - return "Sell"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SideNULL::Value value) + { + switch (value) + { + case Buy: return "Buy"; + case Sell: return "Sell"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum SideNULL [E103]:"); - } + throw std::runtime_error("unknown value for enum SideNULL [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, SideNULL::Value m) { - return os << SideNULL::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, SideNULL::Value m) + { + return os << SideNULL::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/SideReq.h b/src/lib/orderman/ilink3/generated/SideReq.h index 36dd22ac2..bdd437d18 100644 --- a/src/lib/orderman/ilink3/generated/SideReq.h +++ b/src/lib/orderman/ilink3/generated/SideReq.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_SIDEREQ_H_ #define _ILINKBINARY_SIDEREQ_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,47 +25,51 @@ namespace iLinkBinary { -class SideReq { - public: - enum Value { - Buy = (std::uint8_t)1, - Sell = (std::uint8_t)2, - NULL_VALUE = (std::uint8_t)255 - }; +class SideReq +{ +public: + enum Value + { + Buy = static_cast(1), + Sell = static_cast(2), + Undisclosed = static_cast(7), + NULL_VALUE = static_cast(255) + }; - static SideReq::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return Buy; - case 2: - return Sell; - case 255: - return NULL_VALUE; - } + static SideReq::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return Buy; + case static_cast(2): return Sell; + case static_cast(7): return Undisclosed; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum SideReq [E103]"); - } + throw std::runtime_error("unknown value for enum SideReq [E103]"); + } - static const char *c_str(const SideReq::Value value) { - switch (value) { - case Buy: - return "Buy"; - case Sell: - return "Sell"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SideReq::Value value) + { + switch (value) + { + case Buy: return "Buy"; + case Sell: return "Sell"; + case Undisclosed: return "Undisclosed"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum SideReq [E103]:"); - } + throw std::runtime_error("unknown value for enum SideReq [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, SideReq::Value m) { - return os << SideReq::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, SideReq::Value m) + { + return os << SideReq::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/SideTimeInForce.h b/src/lib/orderman/ilink3/generated/SideTimeInForce.h index 80c8b4883..2922ea397 100644 --- a/src/lib/orderman/ilink3/generated/SideTimeInForce.h +++ b/src/lib/orderman/ilink3/generated/SideTimeInForce.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_SIDETIMEINFORCE_H_ #define _ILINKBINARY_SIDETIMEINFORCE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,48 +25,48 @@ namespace iLinkBinary { -class SideTimeInForce { - public: - enum Value { - Day = (std::uint8_t)0, - FAK = (std::uint8_t)3, - NULL_VALUE = (std::uint8_t)255 - }; +class SideTimeInForce +{ +public: + enum Value + { + Day = static_cast(0), + FAK = static_cast(3), + NULL_VALUE = static_cast(255) + }; - static SideTimeInForce::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Day; - case 3: - return FAK; - case 255: - return NULL_VALUE; - } + static SideTimeInForce::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Day; + case static_cast(3): return FAK; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum SideTimeInForce [E103]"); - } + throw std::runtime_error("unknown value for enum SideTimeInForce [E103]"); + } - static const char *c_str(const SideTimeInForce::Value value) { - switch (value) { - case Day: - return "Day"; - case FAK: - return "FAK"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SideTimeInForce::Value value) + { + switch (value) + { + case Day: return "Day"; + case FAK: return "FAK"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum SideTimeInForce [E103]:"); - } + throw std::runtime_error("unknown value for enum SideTimeInForce [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, SideTimeInForce::Value m) { - return os << SideTimeInForce::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, SideTimeInForce::Value m) + { + return os << SideTimeInForce::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/SplitMsg.h b/src/lib/orderman/ilink3/generated/SplitMsg.h index b62be8bbd..6e561354c 100644 --- a/src/lib/orderman/ilink3/generated/SplitMsg.h +++ b/src/lib/orderman/ilink3/generated/SplitMsg.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_SPLITMSG_H_ #define _ILINKBINARY_SPLITMSG_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,52 +25,51 @@ namespace iLinkBinary { -class SplitMsg { - public: - enum Value { - SplitMessageDelayed = (std::uint8_t)0, - OutofOrderMessageDelayed = (std::uint8_t)1, - CompleteMessageDelayed = (std::uint8_t)2, - NULL_VALUE = (std::uint8_t)255 - }; +class SplitMsg +{ +public: + enum Value + { + SplitMessageDelayed = static_cast(0), + OutofOrderMessageDelayed = static_cast(1), + CompleteMessageDelayed = static_cast(2), + NULL_VALUE = static_cast(255) + }; - static SplitMsg::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return SplitMessageDelayed; - case 1: - return OutofOrderMessageDelayed; - case 2: - return CompleteMessageDelayed; - case 255: - return NULL_VALUE; - } + static SplitMsg::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return SplitMessageDelayed; + case static_cast(1): return OutofOrderMessageDelayed; + case static_cast(2): return CompleteMessageDelayed; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum SplitMsg [E103]"); - } + throw std::runtime_error("unknown value for enum SplitMsg [E103]"); + } - static const char *c_str(const SplitMsg::Value value) { - switch (value) { - case SplitMessageDelayed: - return "SplitMessageDelayed"; - case OutofOrderMessageDelayed: - return "OutofOrderMessageDelayed"; - case CompleteMessageDelayed: - return "CompleteMessageDelayed"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SplitMsg::Value value) + { + switch (value) + { + case SplitMessageDelayed: return "SplitMessageDelayed"; + case OutofOrderMessageDelayed: return "OutofOrderMessageDelayed"; + case CompleteMessageDelayed: return "CompleteMessageDelayed"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum SplitMsg [E103]:"); - } + throw std::runtime_error("unknown value for enum SplitMsg [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, SplitMsg::Value m) { - return os << SplitMsg::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, SplitMsg::Value m) + { + return os << SplitMsg::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/Terminate507.h b/src/lib/orderman/ilink3/generated/Terminate507.h index bf313ecca..a2ea3b2ff 100644 --- a/src/lib/orderman/ilink3/generated/Terminate507.h +++ b/src/lib/orderman/ilink3/generated/Terminate507.h @@ -4,39 +4,33 @@ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() +# include +# define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() +# define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() #else /* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN +# include +# define SBE_FLOAT_NAN NAN +# define SBE_DOUBLE_NAN NAN #endif #if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept +# define SBE_CONSTEXPR constexpr +# define SBE_NOEXCEPT noexcept #else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] +# include +# define SBE_NODISCARD [[nodiscard]] #else -#define SBE_NODISCARD +# define SBE_NODISCARD #endif #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include @@ -44,43 +38,43 @@ #include #include #include -#include #include +#include #include #include +#include #if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) +# define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) +# define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) +# define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) +# define SBE_BIG_ENDIAN_ENCODE_16(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) (v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) (v) #else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." +# error "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." #endif #if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) #elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) #else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) +# define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) #endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() @@ -92,706 +86,811 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AvgPxInd.h" -#include "BooleanFlag.h" -#include "BooleanNULL.h" -#include "ClearingAcctType.h" -#include "CmtaGiveUpCD.h" -#include "CustOrdHandlInst.h" -#include "CustOrderCapacity.h" -#include "DATA.h" -#include "DKReason.h" -#include "Decimal32NULL.h" -#include "Decimal64NULL.h" -#include "ExecAckStatus.h" -#include "ExecInst.h" -#include "ExecMode.h" -#include "ExecReason.h" -#include "ExecTypTrdCxl.h" -#include "ExpCycle.h" -#include "FTI.h" -#include "GroupSize.h" -#include "KeepAliveLapsed.h" -#include "ListUpdAct.h" -#include "ManualOrdInd.h" -#include "ManualOrdIndReq.h" -#include "MassActionOrdTyp.h" -#include "MassActionResponse.h" -#include "MassActionScope.h" -#include "MassCancelTIF.h" -#include "MassCxlReqTyp.h" -#include "MassStatusOrdTyp.h" -#include "MassStatusReqTyp.h" -#include "MassStatusTIF.h" + #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OFMOverrideReq.h" -#include "OrdStatusTrd.h" -#include "OrdStatusTrdCxl.h" -#include "OrderEventType.h" -#include "OrderStatus.h" -#include "OrderType.h" +#include "Decimal64NULL.h" #include "OrderTypeReq.h" -#include "PRICE9.h" +#include "BooleanNULL.h" +#include "AvgPxInd.h" +#include "OrderEventType.h" +#include "CmtaGiveUpCD.h" #include "PRICENULL9.h" -#include "PartyDetailRole.h" -#include "QuoteAckStatus.h" +#include "BooleanFlag.h" +#include "OrderType.h" #include "QuoteCxlStatus.h" -#include "QuoteCxlTyp.h" -#include "QuoteTyp.h" -#include "RFQSide.h" -#include "ReqResult.h" -#include "SLEDS.h" -#include "SMPI.h" -#include "SecRspTyp.h" -#include "ShortSaleType.h" -#include "SideNULL.h" -#include "SideReq.h" -#include "SideTimeInForce.h" -#include "SplitMsg.h" #include "TimeInForce.h" +#include "PRICE9.h" +#include "MassStatusOrdTyp.h" +#include "ExecInst.h" +#include "Decimal32NULL.h" +#include "SplitMsg.h" +#include "SideReq.h" +#include "MassActionResponse.h" +#include "CustOrderCapacity.h" +#include "SideTimeInForce.h" +#include "SLEDS.h" +#include "ReqResult.h" +#include "ClearingAcctType.h" +#include "KeepAliveLapsed.h" +#include "ExecAckStatus.h" +#include "DATA.h" +#include "OFMOverrideReq.h" +#include "SideNULL.h" +#include "GroupSize.h" +#include "ListUpdAct.h" +#include "FTI.h" +#include "ExecReason.h" +#include "MassStatusReqTyp.h" +#include "DKReason.h" +#include "SecRspTyp.h" +#include "MassActionOrdTyp.h" +#include "QuoteAckStatus.h" +#include "ExpCycle.h" +#include "MassCancelTIF.h" +#include "OrderStatus.h" +#include "ShortSaleType.h" +#include "PartyDetailRole.h" +#include "MassActionScope.h" +#include "RFQSide.h" +#include "OrdStatusTrdCxl.h" #include "TradeAddendum.h" +#include "MessageHeader.h" +#include "ManualOrdInd.h" +#include "QuoteCxlTyp.h" +#include "MassCxlReqTyp.h" +#include "ExecTypTrdCxl.h" +#include "ManualOrdIndReq.h" +#include "CustOrdHandlInst.h" +#include "OrdStatusTrd.h" +#include "MassStatusTIF.h" +#include "SMPI.h" +#include "ExecMode.h" +#include "QuoteTyp.h" namespace iLinkBinary { -class Terminate507 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_position = 0; - std::uint64_t m_actingVersion = 0; +class Terminate507 +{ +private: + char *m_buffer = nullptr; + std::uint64_t m_bufferLength = 0; + std::uint64_t m_offset = 0; + std::uint64_t m_position = 0; + std::uint64_t m_actingBlockLength = 0; + std::uint64_t m_actingVersion = 0; - inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { return &m_position; } + inline std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return &m_position; + } - public: - enum MetaAttribute { EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE }; +public: + static const std::uint16_t SBE_BLOCK_LENGTH = static_cast(67); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(507); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(8); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(8); - union sbe_float_as_uint_u { - float fp_value; - std::uint32_t uint_value; - }; + enum MetaAttribute + { + EPOCH, TIME_UNIT, SEMANTIC_TYPE, PRESENCE + }; - union sbe_double_as_uint_u { - double fp_value; - std::uint64_t uint_value; - }; + union sbe_float_as_uint_u + { + float fp_value; + std::uint32_t uint_value; + }; - Terminate507() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - Terminate507( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : m_buffer(buffer), m_bufferLength(bufferLength), m_offset(offset), - m_position(sbeCheckPosition(offset + actingBlockLength)), - m_actingVersion(actingVersion) {} + using messageHeader = MessageHeader; - Terminate507(char *buffer, const std::uint64_t bufferLength) - : Terminate507( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + Terminate507() = default; - Terminate507( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : Terminate507( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + Terminate507( + char *buffer, + const std::uint64_t offset, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + m_buffer(buffer), + m_bufferLength(bufferLength), + m_offset(offset), + m_position(sbeCheckPosition(offset + actingBlockLength)), + m_actingBlockLength(actingBlockLength), + m_actingVersion(actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)67; - } + Terminate507(char *buffer, const std::uint64_t bufferLength) : + Terminate507(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockAndHeaderLength() SBE_NOEXCEPT { - return MessageHeader::encodedLength() + sbeBlockLength(); - } + Terminate507( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + Terminate507(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)507; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(67); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(507); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "Terminate"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(8); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(8); + } - Terminate507 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = Terminate507( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "Terminate"; + } - Terminate507 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + Terminate507 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = Terminate507(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - return *this = Terminate507( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + Terminate507 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - Terminate507 &wrapForDecode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = Terminate507( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + return *this = Terminate507( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + Terminate507 &wrapForDecode( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = Terminate507(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + Terminate507 &sbeRewind() + { + return wrapForDecode(m_buffer, m_offset, m_actingBlockLength, m_actingVersion, m_bufferLength); + } - SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT { - return sbePosition() - m_offset; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return m_position; + } - SBE_NODISCARD std::uint64_t decodeLength() const { - Terminate507 skipper( - m_buffer, m_offset, m_bufferLength, sbeBlockLength(), - m_actingVersion); - skipper.skip(); - return skipper.encodedLength(); - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD char *buffer() SBE_NOEXCEPT { return m_buffer; } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + Terminate507 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static const char * - ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t reasonId() SBE_NOEXCEPT { return 39011; } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - reasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } - SBE_NODISCARD bool reasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static const char *ReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t reasonId() SBE_NOEXCEPT + { + return 39011; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t reasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool reasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= reasonSinceVersion(); + return m_actingVersion >= reasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - reasonEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t reasonEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char reasonNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char reasonMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char reasonMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT { - return 48; - } + static SBE_CONSTEXPR std::size_t reasonEncodingLength() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t reasonLength() SBE_NOEXCEPT { return 48; } + static SBE_CONSTEXPR std::uint64_t reasonLength() SBE_NOEXCEPT + { + return 48; + } - SBE_NODISCARD const char *reason() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } + SBE_NODISCARD const char *reason() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char *reason() SBE_NOEXCEPT { return m_buffer + m_offset + 0; } + SBE_NODISCARD char *reason() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char reason(const std::uint64_t index) const { - if (index >= 48) { - throw std::runtime_error("index out of range for reason [E104]"); - } + SBE_NODISCARD char reason(const std::uint64_t index) const + { + if (index >= 48) + { + throw std::runtime_error("index out of range for reason [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - Terminate507 &reason(const std::uint64_t index, const char value) { - if (index >= 48) { - throw std::runtime_error("index out of range for reason [E105]"); - } + Terminate507 &reason(const std::uint64_t index, const char value) + { + if (index >= 48) + { + throw std::runtime_error("index out of range for reason [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getReason(char *const dst, const std::uint64_t length) const { - if (length > 48) { - throw std::runtime_error("length too large for getReason [E106]"); - } + std::uint64_t getReason(char *const dst, const std::uint64_t length) const + { + if (length > 48) + { + throw std::runtime_error("length too large for getReason [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - Terminate507 &putReason(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 48); - return *this; - } + Terminate507 &putReason(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 48); + return *this; + } - SBE_NODISCARD std::string getReasonAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + SBE_NODISCARD std::string getReasonAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 48 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 48 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getReasonAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getReasonAsString(); + std::string getReasonAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getReasonAsString(); - for (const auto c : s) { - switch (c) { - case '"': - oss << "\\\""; - break; - case '\\': - oss << "\\\\"; - break; - case '\b': - oss << "\\b"; - break; - case '\f': - oss << "\\f"; - break; - case '\n': - oss << "\\n"; - break; - case '\r': - oss << "\\r"; - break; - case '\t': - oss << "\\t"; - break; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= c && c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(c); - } else { - oss << c; + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } } - } - } + } - return oss.str(); - } + return oss.str(); + } -#if __cplusplus >= 201703L - SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getReasonAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + std::size_t length = 0; - for (; length < 48 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 48 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - Terminate507 &putReason(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 48) { - throw std::runtime_error("string too large for putReason [E106]"); - } + #if __cplusplus >= 201703L + Terminate507 &putReason(const std::string_view str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 48) + { + throw std::runtime_error("string too large for putReason [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 48; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (std::size_t start = srcLength; start < 48; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#else - Terminate507 &putReason(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 48) { - throw std::runtime_error("string too large for putReason [E106]"); - } + return *this; + } + #else + Terminate507 &putReason(const std::string &str) + { + const std::size_t srcLength = str.length(); + if (srcLength > 48) + { + throw std::runtime_error("string too large for putReason [E106]"); + } - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 48; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (std::size_t start = srcLength; start < 48; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UUIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT { return 39001; } + static SBE_CONSTEXPR std::uint16_t uUIDId() SBE_NOEXCEPT + { + return 39001; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - uUIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t uUIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool uUIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= uUIDSinceVersion(); + return m_actingVersion >= uUIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - uUIDEncodingOffset() SBE_NOEXCEPT { - return 48; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t uUIDEncodingOffset() SBE_NOEXCEPT + { + return 48; + } - static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t uUIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t uUIDMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t uUIDMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t uUIDEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t uUID() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 48, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Terminate507 &uUID(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); - return *this; - } + Terminate507 &uUID(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 48, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *RequestTimestampMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RequestTimestampMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT { - return 39002; - } + static SBE_CONSTEXPR std::uint16_t requestTimestampId() SBE_NOEXCEPT + { + return 39002; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - requestTimestampSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t requestTimestampSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool requestTimestampInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= requestTimestampSinceVersion(); + return m_actingVersion >= requestTimestampSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - requestTimestampEncodingOffset() SBE_NOEXCEPT { - return 56; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t requestTimestampEncodingOffset() SBE_NOEXCEPT + { + return 56; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t requestTimestampMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - requestTimestampEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t requestTimestampEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t requestTimestamp() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 56, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - Terminate507 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); - return *this; - } + Terminate507 &requestTimestamp(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 56, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char * - ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ErrorCodesMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t errorCodesId() SBE_NOEXCEPT { - return 39012; - } + static SBE_CONSTEXPR std::uint16_t errorCodesId() SBE_NOEXCEPT + { + return 39012; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - errorCodesSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t errorCodesSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool errorCodesInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool errorCodesInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= errorCodesSinceVersion(); + return m_actingVersion >= errorCodesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - errorCodesEncodingOffset() SBE_NOEXCEPT { - return 64; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t errorCodesEncodingOffset() SBE_NOEXCEPT + { + return 64; + } - static SBE_CONSTEXPR std::uint16_t errorCodesNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT16; - } + static SBE_CONSTEXPR std::uint16_t errorCodesNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT16; + } - static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t errorCodesMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t errorCodesMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t errorCodesEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t errorCodes() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t errorCodes() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 64, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - Terminate507 &errorCodes(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint16_t)); - return *this; - } + Terminate507 &errorCodes(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 64, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char * - SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SplitMsgMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT { return 9553; } + static SBE_CONSTEXPR std::uint16_t splitMsgId() SBE_NOEXCEPT + { + return 9553; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - splitMsgSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t splitMsgSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool splitMsgInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= splitMsgSinceVersion(); + return m_actingVersion >= splitMsgSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingOffset() SBE_NOEXCEPT { - return 66; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingOffset() SBE_NOEXCEPT + { + return 66; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - splitMsgEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t splitMsgEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SplitMsg::Value splitMsg() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); - return SplitMsg::get((val)); - } + SBE_NODISCARD std::uint8_t splitMsgRaw() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return (val); + } - Terminate507 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); - return *this; - } + SBE_NODISCARD SplitMsg::Value splitMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 66, sizeof(std::uint8_t)); + return SplitMsg::get((val)); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, Terminate507 _writer) { - Terminate507 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "Terminate507", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + Terminate507 &splitMsg(const SplitMsg::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 66, &val, sizeof(std::uint8_t)); + return *this; + } - builder << R"("Reason": )"; - builder << '"' << writer.getReasonAsJsonEscapedString().c_str() << '"'; +template +friend std::basic_ostream & operator << ( + std::basic_ostream &builder, Terminate507 _writer) +{ + Terminate507 writer( + _writer.m_buffer, + _writer.m_offset, + _writer.m_bufferLength, + _writer.m_actingBlockLength, + _writer.m_actingVersion); - builder << ", "; - builder << R"("UUID": )"; - builder << +writer.uUID(); + builder << '{'; + builder << R"("Name": "Terminate507", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << ", "; - builder << R"("RequestTimestamp": )"; - builder << +writer.requestTimestamp(); + builder << R"("Reason": )"; + builder << '"' << + writer.getReasonAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("ErrorCodes": )"; - builder << +writer.errorCodes(); + builder << ", "; + builder << R"("UUID": )"; + builder << +writer.uUID(); - builder << ", "; - builder << R"("SplitMsg": )"; - builder << '"' << writer.splitMsg() << '"'; + builder << ", "; + builder << R"("RequestTimestamp": )"; + builder << +writer.requestTimestamp(); - builder << '}'; + builder << ", "; + builder << R"("ErrorCodes": )"; + builder << +writer.errorCodes(); - return builder; - } + builder << ", "; + builder << R"("SplitMsg": )"; + builder << '"' << writer.splitMsg() << '"'; - void skip() {} + builder << '}'; - SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT { - return true; - } + return builder; +} - SBE_NODISCARD static SBE_CONSTEXPR_14 size_t computeLength() { +void skip() +{ +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return true; +} + +SBE_NODISCARD static std::size_t computeLength() +{ #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wtype-limits" #endif - size_t length = sbeBlockLength(); + std::size_t length = sbeBlockLength(); - return length; + return length; #if defined(__GNUG__) && !defined(__clang__) #pragma GCC diagnostic pop #endif - } +} }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/TimeInForce.h b/src/lib/orderman/ilink3/generated/TimeInForce.h index 19022bc1d..355580348 100644 --- a/src/lib/orderman/ilink3/generated/TimeInForce.h +++ b/src/lib/orderman/ilink3/generated/TimeInForce.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_TIMEINFORCE_H_ #define _ILINKBINARY_TIMEINFORCE_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,62 +25,60 @@ namespace iLinkBinary { -class TimeInForce { - public: - enum Value { - Day = (std::uint8_t)0, - GoodTillCancel = (std::uint8_t)1, - FillAndKill = (std::uint8_t)3, - FillOrKill = (std::uint8_t)4, - GoodTillDate = (std::uint8_t)6, - NULL_VALUE = (std::uint8_t)255 - }; +class TimeInForce +{ +public: + enum Value + { + Day = static_cast(0), + GoodTillCancel = static_cast(1), + FillAndKill = static_cast(3), + FillOrKill = static_cast(4), + GoodTillDate = static_cast(6), + GoodForSession = static_cast(99), + NULL_VALUE = static_cast(255) + }; - static TimeInForce::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Day; - case 1: - return GoodTillCancel; - case 3: - return FillAndKill; - case 4: - return FillOrKill; - case 6: - return GoodTillDate; - case 255: - return NULL_VALUE; - } + static TimeInForce::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Day; + case static_cast(1): return GoodTillCancel; + case static_cast(3): return FillAndKill; + case static_cast(4): return FillOrKill; + case static_cast(6): return GoodTillDate; + case static_cast(99): return GoodForSession; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum TimeInForce [E103]"); - } + throw std::runtime_error("unknown value for enum TimeInForce [E103]"); + } - static const char *c_str(const TimeInForce::Value value) { - switch (value) { - case Day: - return "Day"; - case GoodTillCancel: - return "GoodTillCancel"; - case FillAndKill: - return "FillAndKill"; - case FillOrKill: - return "FillOrKill"; - case GoodTillDate: - return "GoodTillDate"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const TimeInForce::Value value) + { + switch (value) + { + case Day: return "Day"; + case GoodTillCancel: return "GoodTillCancel"; + case FillAndKill: return "FillAndKill"; + case FillOrKill: return "FillOrKill"; + case GoodTillDate: return "GoodTillDate"; + case GoodForSession: return "GoodForSession"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum TimeInForce [E103]:"); - } + throw std::runtime_error("unknown value for enum TimeInForce [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, TimeInForce::Value m) { - return os << TimeInForce::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, TimeInForce::Value m) + { + return os << TimeInForce::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/TradeAddendum.h b/src/lib/orderman/ilink3/generated/TradeAddendum.h index 7776d2f18..830d146b7 100644 --- a/src/lib/orderman/ilink3/generated/TradeAddendum.h +++ b/src/lib/orderman/ilink3/generated/TradeAddendum.h @@ -2,86 +2,17 @@ #ifndef _ILINKBINARY_TRADEADDENDUM_H_ #define _ILINKBINARY_TRADEADDENDUM_H_ -#if defined(SBE_HAVE_CMATH) -/* cmath needed for std::numeric_limits::quiet_NaN() */ -#include -#define SBE_FLOAT_NAN std::numeric_limits::quiet_NaN() -#define SBE_DOUBLE_NAN std::numeric_limits::quiet_NaN() -#else -/* math.h needed for NAN */ -#include -#define SBE_FLOAT_NAN NAN -#define SBE_DOUBLE_NAN NAN -#endif - -#if __cplusplus >= 201103L -#define SBE_CONSTEXPR constexpr -#define SBE_NOEXCEPT noexcept -#else -#define SBE_CONSTEXPR -#define SBE_NOEXCEPT -#endif - -#if __cplusplus >= 201402L -#define SBE_CONSTEXPR_14 constexpr -#else -#define SBE_CONSTEXPR_14 -#endif - -#if __cplusplus >= 201703L -#include -#define SBE_NODISCARD [[nodiscard]] -#else -#define SBE_NODISCARD -#endif - #if !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS 1 +# define __STDC_LIMIT_MACROS 1 #endif #include -#include #include #include #include -#include #include +#include #include -#include - -#if defined(WIN32) || defined(_WIN32) -#define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -#define SBE_BIG_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) (v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) (v) -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -#define SBE_LITTLE_ENDIAN_ENCODE_16(v) __builtin_bswap16(v) -#define SBE_LITTLE_ENDIAN_ENCODE_32(v) __builtin_bswap32(v) -#define SBE_LITTLE_ENDIAN_ENCODE_64(v) __builtin_bswap64(v) -#define SBE_BIG_ENDIAN_ENCODE_16(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_32(v) (v) -#define SBE_BIG_ENDIAN_ENCODE_64(v) (v) -#else -#error \ - "Byte Ordering of platform not determined. Set __BYTE_ORDER__ manually before including this file." -#endif - -#if defined(SBE_NO_BOUNDS_CHECK) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (false) -#elif defined(_MSC_VER) -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (exp) -#else -#define SBE_BOUNDS_CHECK_EXPECT(exp, c) (__builtin_expect(exp, c)) -#endif #define SBE_NULLVALUE_INT8 (std::numeric_limits::min)() #define SBE_NULLVALUE_INT16 (std::numeric_limits::min)() @@ -94,57 +25,54 @@ namespace iLinkBinary { -class TradeAddendum { - public: - enum Value { - PartiallyFilled = (std::uint8_t)4, - Filled = (std::uint8_t)5, - TradeCancel = (std::uint8_t)100, - TradeCorrection = (std::uint8_t)101, - NULL_VALUE = (std::uint8_t)255 - }; +class TradeAddendum +{ +public: + enum Value + { + PartiallyFilled = static_cast(4), + Filled = static_cast(5), + TradeCancel = static_cast(100), + TradeCorrection = static_cast(101), + NULL_VALUE = static_cast(255) + }; - static TradeAddendum::Value get(const std::uint8_t value) { - switch (value) { - case 4: - return PartiallyFilled; - case 5: - return Filled; - case 100: - return TradeCancel; - case 101: - return TradeCorrection; - case 255: - return NULL_VALUE; - } + static TradeAddendum::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(4): return PartiallyFilled; + case static_cast(5): return Filled; + case static_cast(100): return TradeCancel; + case static_cast(101): return TradeCorrection; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum TradeAddendum [E103]"); - } + throw std::runtime_error("unknown value for enum TradeAddendum [E103]"); + } - static const char *c_str(const TradeAddendum::Value value) { - switch (value) { - case PartiallyFilled: - return "PartiallyFilled"; - case Filled: - return "Filled"; - case TradeCancel: - return "TradeCancel"; - case TradeCorrection: - return "TradeCorrection"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const TradeAddendum::Value value) + { + switch (value) + { + case PartiallyFilled: return "PartiallyFilled"; + case Filled: return "Filled"; + case TradeCancel: return "TradeCancel"; + case TradeCorrection: return "TradeCorrection"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum TradeAddendum [E103]:"); - } + throw std::runtime_error("unknown value for enum TradeAddendum [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, TradeAddendum::Value m) { - return os << TradeAddendum::c_str(m); - } + template + friend std::basic_ostream & operator << ( + std::basic_ostream &os, TradeAddendum::Value m) + { + return os << TradeAddendum::c_str(m); + } }; -} // namespace iLinkBinary +} #endif diff --git a/src/lib/orderman/ilink3/generated/generate.sh b/src/lib/orderman/ilink3/generated/generate.sh old mode 100755 new mode 100644 index 200d1fd7e..6185d3ad1 --- a/src/lib/orderman/ilink3/generated/generate.sh +++ b/src/lib/orderman/ilink3/generated/generate.sh @@ -3,4 +3,5 @@ # download xml # sftp cmeconfig@sftpng.cmegroup.com:MSGW/NRCert/Templates/ilinkbinary.xml # password: G3t(0nnect3d -docker run --rm -it -w /work -v $PWD:/work java java -Dsbe.output.dir=/work -Dsbe.generate.ir="false" -Dsbe.target.language=cpp -jar sbe-all-1.17.0.jar ilinkbinary.xml \ No newline at end of file +# docker run --rm -it -w /work -v $PWD:/work java java -Dsbe.output.dir=/work -Dsbe.generate.ir="false" -Dsbe.target.language=cpp -jar sbe-all-1.27.0.jar ilinkbinary.xml +docker run --rm -it -w /work -v $PWD:/work eclipse-temurin:17-jdk-jammy java -Dsbe.output.dir=/work -Dsbe.generate.ir="false" -Dsbe.target.language=cpp -jar sbe-all-1.27.0.jar ilinkbinary.xml diff --git a/src/lib/orderman/ilink3/generated/ilinkbinary.xml b/src/lib/orderman/ilink3/generated/ilinkbinary.xml index 6ef8c5cf9..0f4201335 100644 --- a/src/lib/orderman/ilink3/generated/ilinkbinary.xml +++ b/src/lib/orderman/ilink3/generated/ilinkbinary.xml @@ -1,5 +1,5 @@ - + IDEMPOTENT @@ -15,6 +15,8 @@ 4 C 5 + 6 + E F CME-1-SHA-256 @@ -29,8 +31,10 @@ U C 0 + 6 8 C + E 8 1 @@ -135,8 +139,8 @@ 1 - 2 - 3 + 2 + 3 4 @@ -166,7 +170,10 @@ 105 106 107 - 108 + 108 + 109 + 110 + 111 G @@ -227,12 +234,14 @@ 1 3 + 7 100 0 1 6 + 99 0 @@ -256,11 +265,13 @@ 2 4 5 + 6 8 C + E U - + 1 2 4 @@ -337,6 +348,7 @@ 1 2 + 7 0 @@ -347,12 +359,13 @@ 1 2 - + 0 1 3 4 6 + 99 4 @@ -478,8 +491,8 @@ - - + + @@ -499,11 +512,13 @@ - + + + - + @@ -512,7 +527,7 @@ - + @@ -526,12 +541,13 @@ - + + - - + + @@ -542,9 +558,10 @@ - + + - + @@ -555,12 +572,14 @@ - + + + - - + + @@ -644,10 +663,10 @@ - + - + @@ -656,7 +675,7 @@ - + @@ -680,12 +699,15 @@ - + + + + - + @@ -695,7 +717,7 @@ - + @@ -720,12 +742,14 @@ - + + + - + @@ -734,7 +758,7 @@ - + @@ -757,11 +781,14 @@ - + + + + - + @@ -771,7 +798,7 @@ - + @@ -800,23 +827,36 @@ - + + + + + + + + + + + + - + + + @@ -829,7 +869,7 @@ - + @@ -858,7 +898,7 @@ - + @@ -883,7 +923,7 @@ - + @@ -891,7 +931,7 @@ - + @@ -911,6 +951,9 @@ + + + @@ -926,7 +969,7 @@ - + @@ -935,7 +978,9 @@ - + + + @@ -946,7 +991,7 @@ - + @@ -963,7 +1008,8 @@ - + + @@ -980,7 +1026,7 @@ - + @@ -989,7 +1035,7 @@ - + @@ -1015,12 +1061,14 @@ - + + + - + @@ -1030,7 +1078,7 @@ - + @@ -1057,9 +1105,14 @@ - + + + + + + @@ -1071,7 +1124,7 @@ - + @@ -1080,7 +1133,7 @@ - + @@ -1106,10 +1159,15 @@ - + + + + + + @@ -1131,7 +1189,7 @@ - + @@ -1154,7 +1212,7 @@ - + @@ -1236,7 +1294,7 @@ - + @@ -1258,7 +1316,7 @@ - + @@ -1276,11 +1334,12 @@ - + + @@ -1307,7 +1366,7 @@ - + @@ -1333,16 +1392,24 @@ - + + + + + + + + + - + @@ -1350,6 +1417,8 @@ + + @@ -1381,7 +1450,7 @@ - + @@ -1410,7 +1479,7 @@ - + @@ -1434,6 +1503,9 @@ + + + @@ -1450,7 +1522,7 @@ - + @@ -1464,6 +1536,7 @@ + @@ -1472,8 +1545,12 @@ + + + + - + @@ -1504,6 +1581,7 @@ + @@ -1512,8 +1590,14 @@ + + + + + + - + @@ -1539,16 +1623,18 @@ - + + + - + @@ -1571,6 +1657,9 @@ + + + @@ -1581,4 +1670,74 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/lib/orderman/ilink3/generated/sbe-all-1.17.0.jar b/src/lib/orderman/ilink3/generated/sbe-all-1.17.0.jar deleted file mode 100755 index 67ca54095301fd63ad62b202bb9c20eb7eacbbc5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 709290 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�}aTORUIB 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
kEapCjZutUP(5hK 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

H z(HTP5sNDd}tEyOCV4R3B|5QYEfpJZQ?Uz-oE~`jcXLg>f$#s0S1)r7jg)=+0nQX#p zNU$_*C2k0)&gz&WR1(-BBFwKuCI5^&$YYLJbQjiDD#&?QG*@sY=BvpxpAq}s2y%20 zE)0P9%8iNL$@mG9D0!M&b1skxl&3PwPmndAdq+|6zN50RieJdhJr^W)5`@AUngmwp zCY89CkOrqBO-zIHLbpQy&85sAy!OYWqah_KC9X7L1a! z&rBG`x(VX107E?Dhq`b+>n`TH=ix-7hnVXQgG|;_C?p(jy=0f|;QL?r?Cl-pjjN>v zF%NoIs^tE>a z3QPggmq(|Qu0D#PzVtpT7t-0ipW|H6+@3e_0USVD)cyv3OxZ+L+fBsXl39$(=vs$ zWoqOuQ-rfjjof8ww zt`iHR0;5JgM<_puDR!62IMIlb7kw~sC_GBGsKB`jO2RC6hZ8uQVhDulWe^(j5E>;f zd8Y1ZaQYN7Y3@UM6As8yR17!cAl!mDeF-LqUV+7-&4JSm%N0(SD@L?j;dHqgjLYR< zG+?2?Bp;0Tslj-cz+?yqzzn%ZMA?O`pB#7#{s3kny#RIY6KnpGNK_|ffH;Di55dQ}Pn-pzDML`rNCV&a7huOgY`*r#q>+~nq>B#BU z>5~7wPVUL;Wa^-ssBD_y)2-8`Y>=$eF-e_Ma~D8XtQgv^1Y6@Lpd_7c;|tMSi{Ola zucs*4=G7w&-3I+l{a2(bG(xi?M9o~NU{-+wvnrftR)Z;K)c^@k6@&`{;tNnjKy9Qk z_*7{a%OQ`13!qDYge_oEYW3l(MwDIVi#y|Ilm`xg-s)81j%&HE6@pS9(#B@Paoj5%{JGoSq1LD*^6EfN!5fnq~&YDL;1^_Rd|V$kb4_ z=^by%w#7433fU;x>4{X~(tw8)lXq6pg*n(Xd^^ZB!kvOqwLfh~A4q^d zB*4ZeCAI*OrK!=$>d^3ise>7;1K%k~rT4I;tJA7VPTH#cc&b8$O9ro0>5?Idng!)X z5{&#iC`3jchme^M<;(_9(QF9S%|=kyJPR6_O`y5i4BDE_;SI9`yk~ZVFU?Nyz1bOl zHP0i&Y)*8uE6FswlPYFUQe+M!>�?iFqk`*&IZ+Vb~kyVA{#Nmi946(1GT4bf`I! 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 z%0DEmuB0#Y%e!fsdu1=|fN!0Po28#$B5_|uNg0?V%8y$~uP6e7No!KTH!Z7N#71|-zYO$sgDU$hOh1i}HF0Z0IOKoO=k5UOZ2g`8GG2=FS$A{VEE5|1E)*QF)@Pj$_%iWiYQ zC&kwywSj7~EV_|Az{%tvIhbK`4#Ak}Ks7lQ!$@f0qIA7-qy&&Yr9dN+qL^DYk_xye zqrx-{1f<9~G+|B@TgDZrL}CG}l71v(j*u1(TLG4(McCACYxhp7Raa%hRWPyofEotD``^+-;@T5%o^onk_PYGfNGJfI^^{YMn0 zF658QrE^z+V#*KL3L^)EDT4i}a$pwq@Ch(W1k6I#AqCSyE&$_E+<{SGI&s$ z+@1^m4gv68BXUdT#tZOCI-Ci7SBVsoxkXb;`~ziiR8%ksO~=Lkn5h;wz%yLlGprS5bVHEnnww zbDM$Bm8q}46gPRJMH7T3*P)p8XHl@84gaV1)_f0OnVqGFjF)AZr@kezOz3|~(%Oak&)wtueK4Ch_Xb6t=i~^!X*$qq*R@~!7%Z*Jm zDq-84y<(4cti@IZ}tmDz5B7Jq;M(j!G|vdunCY2WloynoE%>$%5JNvL?y$xw%M znAIRAN&d~SFfT3Hk#4nvS}T{GRM#4pZL|~yk`{wG=kEfBsbGfN{7Og+{@6mKVi|oG z&8lK;hm{TV6FpQJ@i=T+lFREK7Z{o@ztIuITYhr^-f^Q(O~8;EGAv;hrF04{JqpS# zBY!E}!0VVGz4Do8nNqY?)kzKgF91tGw7=5lNh;aXArvdsz-?@^REBUt^2AV<;<1x4 zIk+Rz8Es40;xOOA7pWF&YsME?u_3mpEt2T!#KM#Q3ncsIcji$H^-)S;Xh|)Drb9=k zH!9XSz1tp2PhxXt`&Lwy%`uv(=ngPA=NlzP z-`whfT0?y7szEAP%7?-7Zvw&8?gq!=%cC8g(KyN~>4@s>NaLwfP^0&(pljNi+M87a z$N?F(a}37xT?6^;8{e|d_Ks+00(H;2^wG`kgN7MKYEI!nsDqvx4%$l3mePSu_&U;r+OEbWOt8ZqrX}*(ElM<<3ZzJuZnVU8A?aL{ zPYWX1LXK5nEl9K|xJ8s%)*0Ox!x@&fVS6IFv{TLPK^DessC=uPQo_~+!I34Y{@-bt zo{8hC>FQXbfmW8hG-8t!4veClFYAo8;&j{+wZ@l4Wj2i@r7hx3J9LbxhoFN9%_z^R zJiooQqdgv@wXk24leT&qod)AbYfVcObygzok*4{Z+ha{+s}-jYuxIiFnp8EbzkyZ; zDYcAxL%oEeVwKs(+)-a+>^*m$>m`Zm0nx8bpA5Zs(Mt#Y9MxcR(QNB#LCdCv%*Bk2 zx)PwUnQe+s8JzGnB=l=z?2=?*tR?EKlBF3mQ!i~Wl=AEjG`r9quo#q|$w5M>5>S{@NaCN06xrm(dH5QR? zaE%Elli4vC$?mYz;T~~Df^TjoD?2;V*%{gH7%hjTRZuGfvBz4p3i_BqL`X8X2?

  • 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�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 RZ}f@+?I+a+49F%X2B7L zGlkH2_QAfPO*@K^J9nG-4BJ=)>fJkQHrKu0T|^ikz+d5wK#jSVOPNt0{heNwS9Yo+ zwJ7nAR+x$zXOkR!La8WwU;AOj*VB3MTs(EpX*ST`DCh@5w6jgsitCcqw?iOngn+X` zG7tT710(NQY)&kcWabYR8AqpfwtR;1|YjNAveoHFLA;zID{W^h+o{0{_A1Leh2o* zIg9>e9|(VEd^5f=0j+7eo>g(V1u=>CjQ~Nr)>Bl#6{kGL0WPPwj`nPws}9@Rn~96j zl#`2EdGLE5pq0KguD-&#TIiU`+P{MvLhCT~4>Rk?P&W&7`oEEx>ml}b2%QraRKeiBkZEl2rT#p1f^}zamkl!}vQ`uU-8vWa9 zpd(UqVw@oXQ^T^01|X7&h!DU)Q3Ta=S1j%yq5C#|uxRkxuR9F!QKWTv+3-OCoLHb( z{L^Bg=o^~*%T+kvq#g)_V}mlJlsN+S?+qteu)GUaxkDa$4Si$C^hlmBf0{Bub5((s*HvGbp5o%#Ax z$JLuJoA#Fd$Q8tL0sZ#g82`#}pl-l+U{Si1;|*J6x=w$m!53(HG+R+KFZL|dA>qi| zTBfG>mtP7`Hp~ioW2(biE%}E~cP;nwWQ2|r8Eh5?A==@QCYOZUmb_0%m}}w`=&flQ z)d&fl5)>R~UZ3U%#cxa@vDmMb+JBSSFZktH-J5if6!D>*YTSL!=&!x|REga`SP0J; z>#Y1y-A~eu({jWR;mbthbVb|c_HdCQWiSq3zKuG%8MO2q_3v^U7Eb5*`^fnC>W~a! z=0U|pD(o=ko}Ldp3=VVGYu7ezKKA%ykYl_wXk5SzHS8_Xf>&a(G;-xQvb8FkB!5at z2wsA$4Nr}ATuJ60*V(eJFjk%Ch&*7;HfYV(*TqGVa zp$i!6Ze>*ORIZEvaIE)%yn8Za>7ac8p??!)(rvXNPBwgF<00OgkPU|Kw07r+m>!?R zH!@d|Olq2J>0mB7Y53!U_VK{kLpyTxEx2_(Y5XGPTrEQGtnY}+@qIR;?Rky0Y224->PED^bElPOBG^X{c zw+VPzUzcNVEzAaU8M6AbRsZ)nP<0Tz6bF65vL4n4^>?&E|7*#nX?9D(6ow1@h5~8BmP%l zSr+H9&&m;Qp!RT17?X)8JF@90VTXgg8y(uYwT!gQ9>&_1owrCm#yilv;`kJR2Kp=z z3+i}d%X{kEeX8y9T0p=b*dx$_Npb`-3C&zBy@_&(NM<6;oKO zp`4kNCNp0>yO3|O;+`+tjhv>W?-9I(_4dL(^a7-+KfW?uUFL{xoVE3DdV4i>vpF_i zo9#+lMd3N|+vgS$pnE?%2ybhOrRWVzVXd@ax~8gG%l@E6(uq`$K7u^4fGp-*Z0jh} zJeRSSSwxn@vta;jz0tBzv`XcrIz0CbH$8TX7B@?~A@5u@4M=&0zF+&z;P8Qitg%3% zLysfMJgY2YR|V@JKS*IcW~ni?7cg9qe;CRzFN4uERIbi61HOzmrzx)i|H_o+YS(DW zK-TT#7G;I$&L5LS-$5 zV!!Z_Vn5X`IEW;qnhs^8+&3ZVfm?cgOw~W+x-B01P`k(+jqo&9>mt@1;H&toCc}nm zO|4wLbQWUmm_>h8ar;nw;D}-L_BF@=OP)!NQ&0CZZ*l zuWZE#1|1rqcy}8bg&Bo1xFfLw9hJ#gEvEk!RG?L1xQM3r(C4F6mpK5Zq24DatMq^+ z$qga>n&(T+Aj&VC*G3;0RD_ZII7epI(TYzsM5`aL(nkb@s(m0CW054(5vQRj`GN=MI(sv}flC{LQK5-`#b+Q z{_w1hkl^+?X7HbIU{=czz55~E?Lhzm@%``N@ZVq{Vq{`z_W$Z4qhpVwhWHih`zL1E z&APNrQF`o`l?e}-o1E4B8XKG4FYw`%S{$mIKJ!l3X3l?0SKQR$!~B7Wdv}UN`0*9e zkWj=(U`i2P_c$*kkP*xlosPO$5J9xL<9{;jyE0gupPsw@KjC`BY=e>d&9GE7(JE<- zTd7In0x_$lD97S!sdt;CbkmT;rA7?W6jL2U`mjY-mfY3)StrmzDj8+nXonr(#!b^5 z++i)4#^e8LyU`Rj|M(iPWG>pBXU;eolZgh#P*H>Jgc-B)Prs|k#;;&OSjrNSI zt5|Rygg-SgiTlsbg{(gS+QSWL#{CiX0=Y57um9Y*kKWTO`B*)xjr>s5}PV4fJIv~ zFVnj%07FvtDexqzN+Gu@q-&vBh21jx%qZ$CsU|hNjRK_Y=Im&*s--R-8+~k~*N>xO zBTIk6xND`2&09OsuRmDQYmv24d!*(C>4U43B?;lgvBANQlv_PnN~$;LK~B*I4QF}) zi>j*Yvyy*q8uL7zcY569uH!E4*|BE-yzb2OPoaY96Wg< zD{g#V{ZmmF&mB_BIwa-?9PD@zlBLw5RYvT%m4us6Tqan7y4D9c9SuxD|qdOO|DOA#NBh2^^clrRO z@{1DUaSA%*iVE?H6w=0eLKt1`pk5w(oq3?c1hgR6!dh736}P!R@lLWFXx?rnTcTU! zKTJb@%|PTL3V+o>Y_Pz;_E_X3LUM*;+!P=z-|QNL4tIwP5CnSH`T#v`0omGuvLE$# z9kfA;R{ta?BU$(&_#^crPBt0-_Ng^MTti%VeIML%+e0=;KioD-$Tk?^>)~Z6!l1N2 zr6V55f*=&%^%i=%86_yaCb@&0TOuMSxPGQO3I~6ofV@#4x}VOwnXVh?7L4?dK>I>d ze_b9)>KM2-iSZADgT7CGW`mvum^;P}5r))?c7qxrs|XALxhf)4MT!i;71hZm?$_FY z7)=KW#E-{vA;mcRp_z+v9(U+xsFxKcxZBVK??{4MN)AOt@e%ZnpFup+ zB<|?nK?5}2(pyHNIAw~wM`M(~LdP5;&2I>hb_Iy0o*{He#dS%2FoXmGqC6I}7D+u6?s?>rY^!Hpv6gK5 zfAsxriF*U}=+OIhE`Ht4SFdePSuNe)P&>@{$4Ubn*h7l*;T7Yiw>?QcpZm zbd{|M{gI)(>cx-G%J)G<*op1sd#RBnk!+!VyG=aj?_tH~9oN;i-0-qA+QoW-~a=bQ_28&%8osG*l?*_yPGWvT#E_vzu``G7*~F zwu|V;d$o~tIq$F;f>RD-lpMKtdis~I>ZM*;?)|(YjNL{}fU9R+Xf3(sim*QTmUZS< zOPCh&pfUKy5PuoPfKlINV46S*kiB17N`)JSBMC)=JbaNHOgpGK5kAb~89SqM=Q>lE z{h^~>|ML4i5}jCs*-p^JN80x?8fXF+EEyN@uByOXNxqOo9IeLh_3Yjt0N|%MLnC>(ul8~x;qbCrYYM?c zhCx0?9KHybeAmxi|HYn1T|QRx!sB@#wo$bw=0P=NBR^IitdO-alF@M2!#*hv2g0iN zS#WRS8=P^5VTF!gH!#C$sI(78)dXsLG3OVsA}i2(^IUwaD7sqF2j*-03$I(VCLa5c z>nSgg*k$(JmoQAu>$wwsc0OuW%P-<=)KMyhlD-Lo!T!GQPWU1H4q5wFE`gGb+;R z7SVXaHtHA-7T}V;(anUHS`{2q?OhoM^Y_$^UDz9@tnx*F2wzb0=UJpi=Y7N=MC3qE zI$-Al0h8@wP9avw{1bFf-IA4u(~@~n+bg2i@eG+A8|SYlpH249qx=RxArfX67GNPv zNY9;j2c0J^I3tO+VwY|AyN z{U!*cgY89st2I+CARaI@>pByrU6*A?v(*gKO4RGYK>8r*OX!^a68ze2Z4NW>AFPcd zILlkQ&I{#IEriEEnR;@)FM`?Eqop4`C#;xLR(+N=L-4w*4VJP9jZJ_8LDY??Kne2> z5$*`H+C7Ps9=Y=9aJSl>A~XNFBdaHgtBusSRlE7ZCYXO`9gTVjJ15beaoiXxUFB6; zb`9bx(U8aLXR5Jwt1yQR=Gz=uITWV-heCwELM!PE+-SEFx`yf2-Sv#ZVz0r}=V59# z);)yng4W{(AAn?2@@L$*@e#b08C4}f%d4t1(vCtCoOVqp(z_-Uv5~|V7jUPc(lE^> z=&5U1EaCi|0SYEMM8(m)l&Db3xg}q6eZOTf{~f{Yjh3g3ILL zg$2(20tnRJlC7Bv&^f;qeM?mBm}yhTa(Vi2NYe0mTmN1{(~}Sv0pueA-&D8UYSw(a z3T=l@H70|Ei+3d8M>N^b#gaR%^=*TUDGN`+!%fXz`l7?_41*;m_llyNZFIwA$gsx< z-5SH!15Ct|4$m{*HfhSIJRLYPYBC9ALZT8Q707{pun6!LUZ$dtrb(>vofXM*H02Jy zB#>k+B5NUQ30gRSZVEu%UKtoK7waLHn&loUxtvc77G5PROm2ft#Rm=w1*4HM^mc}& z@z4N5x>0MZ#FYZWiR-^E*ukUDYHHG*!*0N=8boLV+?A)FW^`I%E7|AeURatS+lvU> zOHMEM9*q=?S6(`|9gB}^KprehVN)I;i8!3Q$l$jdC0-4Rum2GE4wJ(6#r{L5KqwR$ zdYS)0HZFmNN?wCJ(_CV8>1ac~5;~_|hA))*>R{cNjVZpme!!)$cf^H%^283T9-M1o zb9kT|p2cWxG>jws@$Zu&Y)0L@1}XL_v{7cZ`l4OBdg?R{I=A@umbhFM$0~fI;m23d z_dY>V@ggB5|Bw}FL^H_51OWo{hbY`A14teMr5!s)$X(G-bX(H4O~KPYFY zH~s3B>B(n}voVkCk{gvf)<@AoTQi8G`+W5%D#!Zwfl+ceW~iHAez6y7K2lGxgDelz zrhht^>bDb{Y6HjH`n>-Ww^L4ZM*l_UiuZF$=KMd$?f+BgnxvzEBJ^`kR%vdeEo_7g zr`#(xW>|4j5w%VNH=bJ&gbjx9&7>F6s=r9wq)WIS2qK3bfH08rxzXy5zLjku?&PI4 zPug@on)o>>=lo<&Kd03Ip(|nc5YBOPGIMKb;c-n+o=3#;LXTyt&2pJd(%2A%4r1mo zKfHUFq-B~(YT&i#Bf2iviS;_r%3yb$uIT3*zu)6D`8sKY)KO?is;~m)8JG@)qnOuW z*D4xFutFjlt2o*kFX{SwO0-%+wjHF>DVKS-(L%p#__8!A zx>XD=lsqCLXE?G$ZALUotY;-5sB2hpmmRWAAfaM;(xZ2=hLLleX-%j@F>q-pojL|c zhxKF~Wp~(rd@X+H@^3&`slt)%ILQ}pB4@V=wb)K3X;WhDbKV}edh=UQM~ry%9IkSh zp${DkeYASj88;Y*czCfd`TH5vv0Ux7f37%XNLAxT&mdG{O577WIKpQ@V9lL#d+Xa+ zMEMif!*-X{Ew>$lF6s<%#2rv9wV{U@<=HjfGwXDyQ?M0ay2TC9qAV0<-Qh1qAl@aC z@J{yWo;=p21&c%+%MHd8X7yX3i{q*`M{@siMX+WZlR$#Dfro!SbsWImj7St`+w|8sngEuqNu~&I;(Y6(0ifCkRgew z@oVxZO+-bgS%MBa*2b9=MW!X4faI9U0?C||4WbV@+%Z_!5>s$<&Znt_(*zO;ud^F< zWwh0Zpnfy|j+X0&ZQpnGLJJ1}SG1mAOVF5NY7$6IxT!9dFS=S?Gq+f&YWKy~XJd{e zVOgFVbNTx;W*t@Yed6#2$F+U&Eg(dmJ5r(ZG{!9n6VajP&|2=T*D$$8`KP0)qdIfW zZC0MKB!7FJbhm9=dq2*OL^7A!9tCBK3DrXT+Bcm%XA%N;-{Qm9He=4_bQvs2Jq+Jf zG%%$_gjHoH-7XCyjLc8+?!ZM#t^f&Zvn7|2JlWZDMAvt6VYDW4(|c3kY0a6#L($0M z-U%D7NQ~(eBPd|;6Sw*ocJF9jE6EhEksesvU%v~Ql-q=sZ9MII06+E#TGsprajmBg zEoS1oi+8@@N9BchPDo`7ihh?obuyKZ&6?ET-PC39cpe9vGIjfW1tf=sLMB`U3%+WOO!M zf#WxcWqU(Zd=PmHqYR}J<5_-$ZD=!O%it%o%bl@}19UoS)2m$*Q{|W-_PYQO6wQhJ zQAYo}b=BT$OwOPNaQ>d;-}a1Enf1SUG)-Gw2rqS(uN&8MU|lPSx3=}`^mnLj8%W)*B8F{OmxkdM1&Is36v^+L`3U0Pk(sbcnmy@ACPM`18b@g0inDADxb? z_dvUPl(_L1Nrr0vIe#06rxRkoh5ysP_~AUl?^Ds~L9{!9rta(gTk6{z=#%=$51{qvehe@YF8(DK|p=FPsQ^mbg8h7@{z{|)zmQYzgiM0%X@ zCF8c-9j_JtNRBds!US;vt~0V& zcw%jc3!3al!uHSEhvk0q;_K!05GO#3cg&ce`V@2Mk=5=@GOvJC4UdDdl>c7ZP3F?B zv@X6E50BfLdzH4tkt4<%7Hb?M@x9t~plWQ2 zN2(i@k5&DRVTGq4?emvoW_{_}(D{4X2%+{!>l%_gfnlNiyX5?3!-?`;Dsn z#X3$TUwjkzyRG63Kut|=uyQFo0eA6sEG3!Qyu(Zxn32N8CHb{Ta}@Vbo63lN{EC9%_|!6B;8HTtzD+0 z_Uttg1&N7o@kj7~(OgV*rDaVB|D?oTg$NtHTl<@Yve+@#$c-aL`RYep=FrnaDv#q4 zzyf|oiA7l;dgvCqm$BcZL#Od(3@9(|fcm_`QEBY+X4Kk`-G6JV6=-ukwL5qtR{`@b z3p_ln`pH!_;_O24gtdU^FK)ScZh|D9>5$rm>b{PpeV=p6e9$!v%~>$=N(y7FSo!rx z%87@Kr3A?H4K)=d_l=ty4Hnln?9hCJRp01Syrn^&j>_$6&hr(&BcVd!6gSYrBKIS% z1Rg%+Md#iFl?U#X2QwU*-O6KIkeeA(oh}H7YNXZ^4_OgC^Nr3`cA~>G4ExG}6mO|fYUD_=!n1GW`D#|FvUhGm-lF(VV< zhG_-ppaGcZtceHXJ{1TuXRc9xLUab3zC$jPL;5-iDo+g;@e;wR)qJ77-OuvrFm^rH zDW4dN#c9p9)D;Y$U@+p<-R>CGf&B_h5XL#r{#Ly~Y&`T`RisF(*Wv#sD zbD+wZhW$BUcS=+W5C!FpqUrTYp@%#X5Y5C{QRwz<%o+IlpYE!2=Af6jf0|O9A4Mnk z|M{l`a9HK$wcs3cjSigNKFZK5KQg$^Y}~39kno|2Te74~AWv$`K{z6oFio_hWwJ`JVK5E@qG*2aYnh+J*P zrCBj58-}ld!%VLBCd6ENOC@omkPz9uyw8_QHQr`xcyh-8ru|!O z*VxChxZ^B`=T`Q1BQcAfE|}f)7F+eNJU--uC+P_!N`(#ak*Yq(Zp_+~^z!Sgnu# zQ#2`?W95Mqf7xb1h{IJbMnGNVY%PSZ3R+BDL071mGSe z)lZdKQlyNOE;duOa_r=U_@vLcBK5Y*Ksi)ce(Zc*&gLF=UmAs)~G0ne-w@Bjf?h07a z3UO%&kL)teM-Mrl$1LrEt$YNf{ za}#Gvi(jKzIi#Ic=mGoFM|YDSZMt0{_9;gOuwOp(bh`|a_hMSES*!+kvx6UI1Y$4h zR$auCLRMXr1Dkd?8on+_+e8QkEHCl|RU8Ceb~k$UkMKrw97S9QhxXF`Ev#X1{KS&D zXjeWm;?IygUuyW*DYL##FD=Ed99CTaQq>3I>LCJy9W!Ovad4kj|2Zi=x#{~ zYkqCu#=xV9 zKwiQvx(63rKH|9P0slo02))?~7q<7LU7KIW0*6C8YTxoGD(tG_sMuPf&^M8hcP`?? zj(m38{}>Ib0<1Nf^%C2TtY?iy+%FHcub+!tZq`|rbq)H>s&sQ>=bG&`>#iuK^oaoJ zq#vrgdTjQ5=J2H=o;3{iCSx~GVJ*!*vD>dKMP#hzWGIr@+G8%2$HwH8NU|aufD)scRSj}`9beG6eS=8DC zw~e;6r?}}WN&Esra3Ko-4-=shjJ1vp(|-C3<68bX)~vuHhZCsn+!Fs+Lm})o<_x|+ zJayQsuyzlh&892p7Be9SEnCmn$zzLX2rFtxB*79PcwAMNZ>GRBrAuN9y@-WF#;k&`6P{()y>6J-Z`;7z~Kzgz_*)7w1jY&++4Q6;n+1Mc?6HN zJ?~XU2cB!B&HGU$_n9zyy1Kc(w1l*^0VWZEt3TP~I?PSy%e2R2lWbGfLDVsNI0@qO>hW}+Pi`!C6jB+~*xAZm=&62~HJBAM)U zw@G{xxB%fU$N8hMg4_~X`dm)9uTla)O>6PG1oUCSOs9wplTkAqt2Mv++w-j1+`L(o zoeYbm!RxK|{5|yVbCK#x%qju-d1uX0Jt^|GqTeUfU(eZu|#5%`YxrSvQ8#KTKDf^#q{P`x5y{w@c3gg_YIYr<5^Za;qp|wl~*a-_Sy# z-$tXm+E`o9(nv7k5(ck2cIjqP?8?$QGyOd(kZ@Fb1Cp{d$!=ch0X=f?eK)_Dm-(IL ze^hD{{1rEsQYNUPbyXTS59j9>-nCo$?^Fl;dt`TpF8JEA4-{T1qqK!8tH z0rNwL7l^b|sPz8SMIU}Lu|?tSl*$V}BcX%uvXsN@XOibSx!(cc>D}b(6ysYMA0HAYDBm@V*W&F^Kd}e}Wg}L9bNR(`#X0e` zBthvPxJ`(})!Y z1!-cc3Q?fB=tKg@|$L zz2$l%L+VX9biF6#UGnVah$ivo?ql7_n?4m&C}fX1d-4}J-@+nVD$KXx;||Xog}icP zHU5RGBe%mySXALz(66#{crk9qeNEx`n<{&P(8yYx zwPbpEg`_a7kI>xjF?+0!=7H62oR3)1>n^`?MbdVTW(wVI_Jy`ew%`t;1#kt-q{`rp zse`26>)$3eCUtzBda~UP#sFYOl~}cWOB;#S(lOnPA$QX?N&`8Gr#W7yo6dQNEP}Z&bq-2%YZo}W#q=$BN@1n01#A2*xQSNh% z^T{ortcUgjLMG7AZ)LTA<07FWnJ9G5@;(7s7cH5P|=2ol_1 z$2^Ioj?0Xu{`+zC3#PK>AuGWdYb+7|4+q-D7j5rj3D~g|n7eQ4PM5s9)=slgcgMKG zS)6j|^;$ekGN|3aRn`c^;6#uyxxy%cgLIegnA!szj#YEQ(zT4xn~WB*FCiT#9oj~= zRv?e)c4H5qS(95E!^1scms^@Xq+}fUIUMBb1lU1B$H891!t#qOaCg&Xg?kSfmniZS zVc{eG!wtjdKoW2Bk+#uT`HozexL=&@sY=}Nk5Ft3D_tycNJm9l?P9n~QcRL9^! zaXH>4yrU7|*db4-iXFL5r>uY9U{mHmSQGpN8%~9+3kc?o->9kzzDw91ShT}l&EJZN zFGK`ycr%5bd#vFqime`MFg?+}Q3mY5>x?(C-8N;O^QXc7*qg`?YmN65(EOI7nnF50 z8)}0a>-56CSiOiB1#6qyEyFdtHNM|wI>9ti>n(Gy%Rc?r9Q+mC51Ik?CS1)W>l|Wm z9u!lpybJutpW-co=xYPw5Co*+u_Z8OW4N9Rk@t!5jV;R7 z<&LhkS$9>dbG|k4FNQZT=@34{C)?t_&>7SFqDkdlT+kN#N}v=4o#eeUPR~MRU5qJ% z!hs97o9aoTk$X|c(u8HzjiRlb;vX6SA2s?TTZRvG)^!+NW?u(f=gT=0@W9jPIhRLz zG~tF8Ad!GSfjEu=A&pD;0y8U+2_202jo)%f(5AXz3$`vrnrnE4NL@XRAO%h^mxSBrf9AGkI7I{&T#AX)v0#0_ZtIb)=yTmA^d`r!4k( z7B@#hrZpke#Ey+YwNdX^^jVqa?P`D@=xKLyDzHq}7Mnw*00dMnC6w@+;=4J1D4?mFF!2(yHk;tp?EXL9&B8r+;( zhgJeaF_Y3I>QgN*zu=*z)a-%)ap_av-}QzBi?(p&kA8ug)EpwrS(IrUD*X1vjvX=7 z9uR7`hwwV-)+RiQ%^~GIC;qB})HsGPDu52NMf*!ND4iSR+~SHNJYJ}91tMJ7p?U3H zE5?-4OOd+=tl)H6USIHhir)F{pZ7O7yuc8SeHSve5GWu74V(37?PTua8Ng^RNdb^PV(@J&x`L`wG| zmpLF|MZGQ30`N!Bq-{St?)LsjOIpB_mpu|L)ve(o3=WV5<_RgPJ-kl?Z(4g1z zq)GSu5Zgbk5?v;O=Ado$sQb$0gsK~XyQW2Tj7#;T9SgseHEFcF_RnJlRxWboS8xkC z_jl=x=U^m!AtQsIdtH4<9sp4qTw%~0EZAI1@3Oz z5DkHd^yAOa4Fh46fiOA(2`aDf{R@-!NE{6^Mux;XDSh){{R+8bo!B1c%@-J1T6rp5 z2K{#OrE%89Ap2?*UHxRX#YMJ7t%#|b;F}h8P@ekkH7y#c-cs)G{>q0;5*HX7-;#kh zOSg)i9M_ew>5?G}mb(|RYgJ(8`G&39?#3p0E3SdqwWDgyLR$;$G9_0DvYSDVVF}fK zan#bCrItD1#1f-AlTG)WR`4v=K^2KdBqH}JUF?xVR)yudjeigQ=w1LZY1o2Pj+vlI?7lT(+6UTN8~BtU?~S;A6a#w(6nR z#%W`4QYg>!T#idOxGZJxq&db)9Fx_SM=8r){A|b_-*3n}0aVX?>a$7-vbfMeO%;Mu zY@PY%{KLMH^>P3Z&&C+lGCkp9ZI%?PEWBndqe5k)hJSs{lXW1r4SnYNA%H9s6+i>6 zRhGZT34$`va;avi+iEz>4#(v$4-88bvopNEKu6*VVnIr?*O5oR+EOwWAysZE-?K>A zYIWyjp+9s%|*n8!fY(gvkb~QeGlC93o#+NS{OL>PYCAZ=y~+Mo&uoP!qA8@6K|Baj$Z@ z!yY_@Ta=IAq-Q zYuO!f?~Pi`(p^y3otwE$ihVB0HY&rEgl|-MO>pYNOPZWxRNOx?=8F`@*V&giNkyHN z$x6%uO$&=e*Q5dt@3mCC)&1hn4m=G7rF1(%ZVCz~^Do!9Dxx#XVJZzCA+R;7u$lMc z8x3tPpT7NQH&y)6KLQDp6ueWG5}o-TYBK^j9=ZG@9*_AI(O^^>1ZzRbrJt1ji^E(8 z0U6c&Q~9yA)%>JQ@ws1`{Fa5TN*yL;m2qH4i^I6Xi^HbxXClwj9I zU#;$_MfEzY;u3Y<;a(eu1;_Vqo)vnwztMr;sVe4kO1Rdp5o>cp3SapE3ps`69qZMd zhCJzJBWk%C`StL~Jn_eR_ErmFcIb1tX_Qy~$r{Jr7`(a@VMT)9 zp!2WJZpaK8yvmC{V=sd}dnJWXV=L_hh3|sR{zTb$q}kc3WEJy{Ib+JH?6lK>3(*9W z;5sSf?ns0DDJq|YyHJB)kz+ygci}9@9wbQXUuEa~1HiW;P|O#*_I7~I{OFn>zSRIC zm6%jGQ_M)Yk&@PO<4^;Q(tDX+Ue@z zv$_@**b4RgBPQsz{p2DRzse__$hlVH)CEly{p?J;`d+q`=$qL5THc7Z+9(&CaIi)& zh~LEPQW)Q)ZlHPJQ*ak4g8G*#*R1XQ4jYn%?4VtBq*Evel0XKzG*W;sY@G#(1N+=}S^rqTjUT#Px-e}-a8Ge#7OAvvjmgTUYn6xGy zWrsRHeL1t#pSyA|F1ZDYfcS`oJdHJeKjO2h**`V$ITkY3_;I_xU``JzguNGqywwuS zeA}E7E;umTu3W}fq*2*S=&WP4f0sf#9tZMk*TLub9|~bdUG)KFs=esY_3oUsr6rYB z##bm%)Zho`T9+##%z1isl8CCUN^0C2jBfFJuSHWjneqUS(Q+33WP&&fX)=P!#I?9tVvn>+KIKUWtq zN2?g)t7*8UG0Z7mPvU=kp{BNY6C0+3`c!XG&rME!QdSWM|K$p5XQ>powGjn%62 zZfPU;#r6w(noKHk!9w+uSH(;v?vIh#K>iP&5_WW8_&mvZ&^Vz6akw@;^mzQ$OPA~ z{H>kTxQY?xNWL)36474K(BB6gD|+sUZhs17*rb@EmF)?9|1ZkkIYyM|ee-PFwr$?F zZQHhO+qP}nwr$(G-M6_tlbP)PzB`+pNlxmI%BiF(IrSdA@AG-Y1ymXy)M||tt9?xi zgABhcnVzjIntgFkuGr)oz9llN{W2?`v&=icH7eKaN=4pjn+5w&wZFJ;=KJ_--ffmc z|G|B^a;>Zj_`;Pd8-dCkVx?G42guZv@xKc8q%&UG8D!yoN5w9R#Q^Dswp(Q@n309i{UjKG2hp5ilh-%1=LcCJJrJL+Y1u!dWWK2OQbW-*4cA zOfTJ}q2mqHlfdD&Cz1A7-FFQRt#+amiqDi@8oFzhtTu?OXH?2^Q&<~;hD>2JBpJqOdOTa z>cVHS!OhyNfRxxGu@%ZxL}#;!kdQDK7{*Jq$ibXquKoS2FXVcDAV?yTVC9JUNXZ)Y zK{OR0LIixIdc&}ML6&W{BX-+ukx9c-pB=Z`p0n(XIy@g=_cv0GmK)&s%j-#(4l3s%PDBj znsQoY^Rh1el;+87Rp#N&2Fi#-45B3HR;49L+1$)UoG2`%r_zeGQmRawD-_1o6DqJj zMha{TV@`T?wP$&|OxNxXwlrzG(LA~|u_qJ)`I`i}19=!EDaoWWxeIk1x0%Z4=`PKS zsDl9C#C=oqZT!K#1k-vBI43m+ACBp3*K{AAybC=D#P~TB7Ch?>!G@!b>-W*A4nbwSKP4+{Lq>;uDVZ4d7{t_1IsJ_(SiW3^HApbx0Pux%!XV45G)d zfC?g;B^;NL`Y?gE7Q?m{1O9VTdLJS;j}J0;5T6!sQv_wg zNkz^V^awZThM3+Lv;PG~9fI<}L};Ek$$=$Etk|vQ318uUJqlq~p_}^!@HO#9^+1uJ zIN?F1OjRe?>$23>+W5DB<&JI;q;l5|%@-y|d1g)i4cPg?Zhov!B-$?w<_B-+6Fm9} zpK-!(kn)>(_DRn^V3zK2?;h-D$L5b1D}0jG;xT2c56j&AwA^$FqcF3C^KyP6yqN=r z#wAuVj1*P3#xg~IB)tNQm?i3ZAs|}|-h^q! z6d5a|7jN&+4jWzCjkc-ukKA!$9_9}vA~fvcb*c%O1+Qjr{oODPx5 zqjI}%##qnU+r-l~;2?OfyPc*p-!rZ~j@R2JKi@aVe#~`&XCll&==RwvZ0_k0hPV&{ zuzHL^q+O_mOPf~OroG6(6;qZY9bb<)H8#}hkonLn?r!{k+FZW<10g(KD8y46(9S>? zzy=w)#9W<#*bZ7BH92D!<{WkHJtoD!?fmu}Nq=0r%rSu$C#f`yy_l6SxN8VV=N(s? zYrG`3>YcgFAj>6|SgJFsbty1F1Du>VsB`9*RA-lwE42SerDtSoh?B^8O~X3K&|A-5 z{TrYnh-FG(Wd2*+ALyzaZ|uXnpaQrjZ5xzmku{Y*D)?~QX;5>1r4jTrSMq#aX>0Pf z!~D*!6#y{6bq=H?cFgP!Ah7YG9M+k}2f^lLeh*1CdTg!|ybuWynMwjat0s&67d9x| z&1wNk1Y%wso5sZ-NA<-zVbD#bBRQ+TP9$d$9Li)aNfX!w`*z2L4TRw#_+D3zel1vCZ{l$mf;F4V71)H=@}t#k6NnjO0}7JLs-KL%C$PdhX^eT zrz}ZG`+B?4#$?*r=CL*ffNo{X4q}5}iw==6IMqpn+GN_aeUQf`1?MD&>ir=yQoy>L zJ@kl5HeW8F;1F(+>Q90~eTgBq2CAEb?g&RZceWZor}LlvBBB6BROI&ZLzYnxPb;S^ zI@3n%&=R6J+{H&C`s}vANb2@UfHI1&pN$)!1I;gxSv=U~3v?70JWuv!~Dw!g;kE z6%|NGOW~@!9ib1lef1kT+-0dBbb&r}NZjrG=dR0rJkqVGW?MlLoKv(?7k}#@_Y`aL ziyP!j9~QTfLobAeG4sfm8-d7}>w#C?4N@2m^(FiuK(qVcX72_%g!PEGFuQLDcFAyLsio@=5sgo= z=>;lc>hFZ@Ng>imp^vJSN)IaSh)?Vi93l7eQFSPDxw(R8rr$X%Ap?9sK+j%SHQlKQ zpJBZh$Kc0D)C3MCL^8izEdF{G(6bL@*+%$j2!bA&BUR(-sOi4(MZ^m~DSn!<_`&r( z6MTcrJPqv$p}I#x-wsmiK+@(JgiF@|^$`qz<`ypbxJ@j&jf@57J@Lp!6aGMn_=@_x zV!!O%g-`kECz#F}^vCF-IYK7I#@D2el2*DXg%nHa>fW|lG&+RR-h=;)Qi3wuESkv1 z)vD0oEnuiD?;Aj;*vUdMt4b`*Vf$Yp&p7}4#%{U3@UlQcsb;@8AI~4 z*yrI@lETZ*(d;^(TDfm1$PtC4-Xm>Z*ka@-ZOXO{akbNc|EFu9lLB;>&F>Nv@z)&p zf2;KTe;E+}hca62L1MoPgy_(>0w}sYgVykI|>uh2^iHuTHDQt`U zJQPx3ljZJ0Ji%6#XMvlzpf{PB39{wtWQHYC5;F{~(G^Eiym;o{`_Dz2$h74_D!bT+ z)ppyPKtui%8x}9VRk^-UHJY9AJu-RrvV#|) zHqWZVGGbiR26rcI1#^F*IeO#qvM{Q_{$^~3(hl757^zj;owjz?l0~-Kl1S#tGbT2! zOyl0VhYC^hSXH_%9C9lBthRSql$)xy7n!hHNwX6kD!>LIZftfK?#_=Ga>Z%P^cFfS zG{k5)?hKyj;W55*C01N#lcQn} zSp#_o2ehVW4}(Yb4vs_hCYt3PF@xeAD-Zm@AT`0Ad^T2In%>}%(u~t!i3Y%!j}xjA0#8mw70 zGj)+FRGhx#-p;hRkNc}_b`yd5aHL~>;7|R9{Fll@J}sr#yz7*nshwPA^J*I4YrN|jGY>gydcg> z;2H?uFF*WMkn8_z`~Mp;Q-C+_DAE0DepeV za0%ezF7iR;8eGmlszeb9j3R@1a4IzRLh}{tc%eKVVaJ8IN8T1ZcTn+fo3w6OUAKI( zw#kYYp1aq*%SP9g&*u|p$MPuoogsp7Xm~KP3d7QiVI9yM@U8FzQU>%Y^`A`Y6R_6B zAyaKuy`riPGuYdp)zLYL^268`6mOnIF+IItJ-tSpvQKw0qdir>31g={q}9*&hQBwC zY!=APdt^Iq$gjO3fupp{f27oN@4GQxaG!B8@m`#`b2-oV4u%HYkHL?Jgq$bh z=4t(cbpL6=jPDr;f8&*%;NzH)Yd4WP#y;3(*M_85HEBb>c9yeBfP>Emt}%*G6HoVJ zbH8vMyxdQZgr_l-N?|MwV>mmKeMQ{@FyHa^|2t29(|u@UJ9!w8^K@ITBYs8wV!gX` zgGH{*)2IsF5;k+m#0oib)4{##tmIgs*gip0nL5bbqTaUO(TBgKT_>p39}SX9_BeCS zEHxXP;k2L86+P3SG3*URXU8X%gM096CcXw{QrpRfCyqOE49{VW;lTg?57FQs5smR* zItc(j!vC-N>wiH;k^HBe{YDLC4cGVfRvRo;fgf0vqy~#+iq6hb7&siM(gj;siGmR; zVu-2#oJqVj|H?kn@Bpe%*g%~adf zKyEJ4$@OgaqpNT2?3L*$j?1qXbRY1u0qoU)GgNhYm;qXAtOSEaTlF}4bB4092u}l7 zZj}g3O^gl`GSN$vr?(VOPc3dl(;IkCxyz0cO>C@f<-I!b zGdA(l7H00ii;+9-?y5Z>!!I9?Z`na*3>qklX3VLsn0tz~r+Vt?VX-N}5oZc_GQA`F zH^0E0?PAtBjmdVEu5)2cW>mt%b#>gS7~A&qd`yZbm)WtQbn0ytQOFyRso*ur*aNzT z#ID$o`Q7l)8!+3_S=p_@wYEtcU#^~zc-e-#g^h3?u12@|hb|x1r0m>fr~XEr7}_Z* zmCIDtRD6ReTP7>RVX0+>gT!)@BfxU+LSYJ-yA|e4FJm z<6^4&LFJ#wJ&{$??q*2x>*yA*S8ALsf4jGBOZFE`Q1s}QA`nwfgY+67BmBxm^-)Hv zkTdqtP};Oe6SWa1vrfQjZ>tj!QB`B(ZDi)B;F%}4IyP`A=-jL`DiERGbK{6sfi-<* z2B>Fa500515o3NkCeTNk4Y~Z4rqhN9HR}vNXyQ-Z==lofT4v)?so6hUHJL3;K?3=P zWPiN%tirbCd4+;}c+Qe8>J}6T3UU{EuJg`PAo^X`UYzjY0A| zVY1}Se+`U_u7BfRYR_=PtF~JGOCna&qw?51 z%r_2SgMC~WsO7qloqmmM=6gC{i+weBxv>wh)RlKD;JyJn*iSe%m`^-Eg!Q(Ajj?yC zEZSAIlFoDr=A2eXZwY5NJNx~n#S*KNC;nmYql{M!yK^AZ!SU%Os+23E^) z$qbK`yqJey{OM!x^=LK+Ut|14@L12us1^sR%4!m{X(+Hl9;*}a>QXKrHKyQ8^Nlnp z$O+WZGwz<2#!^*VddicsSji;(W~KgnHBgV;5PumE$Y&fhniFI(Z^FY$4PgUXinyyS z@0ERFRa;?ys|wj#rYc$2pn%Gix?D+iwi)L|OF0E_dA^() z-gD-wiO0+Om|VN6ub61PNDD8>=BH9&uWk(5t(EwZ@qSZO+0|!Zlzk6h!Y2gL10zwy za2|mzQD<;yAHSD$4sWP-C>gKdN|^D={EV4&#Dwkg_!kQl3#es%US9pZ+hlgXz%6X; zfDZhc(C3|iF=!X!f`j^45Q4T^a^3-lx)Kf#g7rK<3EGR<>^m3r~sxK5&<&?JxZ z33#YmR)NJHa6%J$!$y3WM~cjo1|l^rK{e9W5OG|Zjw{M-Qung#+R!)n%w#>lQZex} zdDw(cA~jUgmPd-XOYChiAH7Nxo!n;|aCzmhR`^u;WRU_g=kf>RiqTAXXe{9SIsUXb zWza3QH2I|3=GFDlgn~Q z|45292bUrXpOU2DgyOb-uzlXvyg#E#L+g z7d-OhRyp79DjG-fxX!egFt$p1eds8c7$^Fj#XHbSk*dmj^6j*laFXKJQVrIYB`?Ss zK28IiZDvo`I*xOj1l_JjSE!@=5F`zv3MJrrNR3fKj`(*Fqjyrp4F9=dyHKRSCA0wa z^XT^lkh*zLia+}1F;(rX)IH-8&uH+dQ6z`u+7k5bw|*i|xm~^MOFwgIsZfk`3NS(h z52iT!rJF-Tm=d~Cqk~i3)(xl3O{*H%dGV3#4x!r`lKPZ*8yE0u6s-DQ=ner#wK}dn zn|l1fV90DGOG1oxc5aD`!+zb7^3;Xw!_WRWTd&>$U zQ(lR?TK527@n%9j)cx9P#ycLW#y9RI8}fz;jiE**vO-?aNrvd4Lu7KMz@m~hn$)93 z3%+Dj8EsmR0-OD(fwPY_#NDf`^7J2v_$5G>Ohv!aztmqI#s8M{?|<%~{@+B36rKM@ zqzK&$@NIxuBvM8cS+2YxvJv3@Rd6dASyv+fI~J%dnNUbg(rxS@{gcx+FXZpO2Y)My zHtR&y+Kdv+oX%!8n`JiJ&Di+H!+kZv1IpMia_6wv!57h_sk!8TD1+%qr9@OK6C+34c$ump*9&1FmEbJ#c$0 zzm^blZyoBNN+r!v)M>9R-gn#sCD~+X4s$jBJ~;NTKpVQUahrX%hb;N8(|RM2!b1+ zLhLnEtubiD4ibS@ReJ_8^g+KiCUtvCM7U>!4NCQUfQ21PxR);3=#EZP)5ucq{tpB z(b$o>7QLe=RncU5pr=%4i1-B(WCr2g)30mM`1L6s#k0Y9hIi;wX#36 zn)`d23IP4TiBS4~4E_HbR-vNvduo8;E9;m@YM>=ZvjBuv6@OZUP`-`^tX@o%fKn;Y z{Nkj6w*F`5=9&)oivIjrb_~;G6xyy?_qk9-YGu~_A_V;%eA&UdwCx)Zb+4&Qh7F;# zfbA^%mFJ9m?#VZMC-3{?8ysLrJ@x=GJK6|eH{1w{UNSv4sEA~nK4K->K5fKa5~j&8 z9eK!tu^Xq%sV>|Jm2tZ5P=zLZ#R^F`%|5i?rQ5aR*gW+x9ZiE-K#C4C)Ko?lb!*i+ zw8&&hlahiu)q(9ge;2sn==P25RKgROa^1v)B|wT?!0 zB8eueQc*{qMrXY@3EE*;G?6-Uh@rX4djT~uvl6`5`vK4WX`=3AMrd2f0p*4JpAJFW zwOK_JhUT+oL7Z75yw+BOj<$`mg6-9vlKX*lt8k+7l0C{!K8>sK#23R0a}H5`d5I1KJ))~{jb-GCqr8k3kDEotG2`<)i&d;HElnL} zt#iR=a|!K5<)Jy9m9s`&qG@OlJohYt2aFU+P;DuN!0R0d5g(4d9L;8INjY4KH46d` zpcQqd3QpP4Lu7|(#cv&dCt(Y18}MOjG@bL5I}Wk3F{a(VOz1%vWpzJ0K@o7=ggZ1b z6PSGb!=KP$2AU&`UBsa-rr4+*Zn!D=dI}*Cfx$$W87|gA`Slax{6)5DXrWRK63NuU z%1jx($bkW!Ue8MP;YI6#HP1S1GhwL`Y*ynU(d&Fs>*F+4R4-MpIS1?nbCMvKHb^hL zd8Nap!VS34bEDokUuZ%S5sUu%y%tVnNCkJzu?ex1qK2?)xeFou!hiB~e$X^-*ah0R z*!6aZx?&%=_soNxG2^WEuFwlv&dEoR=%KX_)Zq_R?BcGIK?6zWpxY_=M(0H>(oJn? zu4eIU%@U^Kf}(--L&s#Kmu8=f`;<#jYQU#O}*;%6dDxovmvUUV_fh>wMynI=ZqS6LK__iRsEdg(;_jPUneqds50DP)SweKyGOnRPIXYuSW@^79sf_PIo08)*k ziQ8y`O!M4`!ARukQtaFD@q-C&M4t}egEa=MB*pX@a_l;KH#}@s8&7znbHYDTNvM8k zBKR-Vol_RFVPlTi>s(uX0j)0Ab4%H8a5se2cHc5rB=}ve9&I1K=HLVik7~hhcEcZB ze;@hgM}CCif1rClYpaOQ2-gHQL2E(lSBO(R1wG_B01hC!k$MqX;GlE?k^! z2|p>MEZ1+YX%q6y%*B#TPfD6Scgp(&pJnG|H~Kgf;xej8%lHP!`@)X3Ks%pXH2`LU0Ge1Fl-G1RcU%eRce(fe0?ZnYnD6fUE?lXij}TgRuN;l}ozqQlzXR?{Ko^UQmn&~vg~ z(gaetIumYG@k@;U>zOe6m9Aa2wb!_MK>3Hr;zX*|O8rk#wz!EMwp+CHLOpZ_)vWsu zE1-hn$c76k!IQ|6JvRy3AMd7P?LUugAhU1$sB2WFwyM@~x~8cp)K{fP75u-W-8#yz z7?CQ|b)dv%{2qF{gC0z)pK)zss}Y*zaUMhP>ZQls^$whsu{@ClZ?uJh4Ak@WLfW9jl|hI8W9)RU1N+KW6?p^hHu1-6Q=rN{0PjcU}#tdm-6|E%Vk*>`Fx!o z6{sSJ2s(SSjB2_xVJ^$WcO*0n{+~!;Z;4T=Oj=FX4pc|wpEiLxd@Sb%TkgW>GI*oz zvfwziYZoJ<3PqatW6xL1)gBt5$nnq*zMCAQe@CB?AV4VKCxDd;TP-6;lD^tu9-=Sy z*Za5F-%McauO;Ak0>${m@v=V<56FRfMgP>y)mCm9kA2J!5e4D@DGQO0r86yk^DBQK zmvzXg8r&nz0_{q6AfF#~jYIAxx4V9(7RXJxCTBaWCOC*Zfkd1?z@YD>zbGV8Dwx1oT$D1 z{L&W+kcp?8{#Ay@%BY(8P_kFT@?xgo?io@PkRH38V@sP88xbzxz2ijyzEtxxN0jC{ zaQk-!)O2OG_q}-O*jg+GUI&xO5fjZ3(9IP}xe}9lF_3sMQhwM+m^m@sBvppd>{ zDIp3{Q^p-2+=Van>DKKb^qyejolZ6a>} zish58SyH?u7`Q6RoE1_gq`gCxckiEgkIr;T*&Gf9j084hUxKG}Ak%t(^5MCqW-9(M z>F#e2ri`|0ZTvXQn$3UyNBHxY42!b=-RkW9CXD`%l12YZ&WVlO(tpF$yUk&Po(>1d zg|io28Dk?Of)GM4v>O}37&E?K)-Kl+cj;`#p1VDUkU@>2`vUMKKWwA18hJ6Mmb~VU z?RA_zyY~71yg};2$|Z^$aD+gXQzkxAnp22h1SG2#7g3}oYEL>;k1801d)O?^q+m98 z-ZV>gpR5O_Id3(>>@eFLq*@MEbz9;ky$5#Pq;+?RXl#`-^x%e~x;!^~2N5=!;bX!q zxhP?L^vEvR!+9(bNtN1OZCl!pCBJtt62Xr#Z0xJfm3xE^@oX8$TMA;#=8ovB5xkC$ zi;ceol*d{7t;Fs0rR2p-h=taGg-nBY9Kh zl)CJ{<>-9aPA(dUBSANjftQk{KYbrgo1O0mWWdw#R;gy44pL(4k?f zj(g3-_#-BZgClX+Lm3+=P+4SX4xqgTyEdaT`D}8ndm7t^{kIocXN%PYYDihm+1;(r zOv5(`M(R?3G+ru5W&93J|DrjYTS9?>!&h^uxJNYHw?A0*4XhM(7U5mc^4CTrMghSP zdOSWGcF;bBva8{nV#P zIT1%oj5PJ}0(83V(X+uDRqdFRi(p$)_1K%urc|OcD%`?69M*=&UkJQz?oW!d(@oeu zT*m0&92T~pXmmh9Y|a(-@!cD2)odo7=(ox|oR$Bj3*raxUw1C7&5=iegugSm8UO&@ z|G`B5Klvyg`pPRSd}lpuPh?5pkimeX1`!B`OdACJ@d$%Rt@R}0@iU;I#z4dq(%I4o zC!wBKr3=Jz9|U86*fDSi<({SDG{0n$s2O9PPS9G6T`+b-W4GwIE)+C|4&HnX=!MSXi_VKdry zW3caWe0^%M=Z2nk+7a0v=KN!`cGTlwIkj&`3HIua0b_;$?XlzR9F3SmJ5VLY(7NTv z%CWuIC*=%n=Nn?QwmQ~Cwl@dTa)tmM(A(%_#&+7nw9;U~LFP}Z#y*vKk zz8DewktU6PS z-94WCxpm>vyR{!;>Ry6vY0snIJDLLQ-5!nVlN#&VsYif+j1%I-a~(o@8hdr=4hzFG zCVK6>_jB%!3&TC0`r_o>4^<&i?)>!6;~uXGdwcBj{#OtS|Ab>_EP#8U$~E;&@pHYu z%1HJR9y_M29$yN<5pvLF07EboLmt(_ z5^8l!Fo7X3$vjeRH1aYtM&(I$wyILM2M@3+!dr!88w)zv$S_&5-4mb4{{KA&Tj=zS~cOuLsGX-5%h9VsRlnDpgQ#7e@2UDYyH z3(0(^lW0CMsacmOO%;6;32u0^kY$MDi%hw}bEbOo@OC+Si{?S*;wM`=Vrjn-urUo- zN1$S%;_D1M3=oms$v@jhCgYeepYvm3$0DyfA7wC0Y=^h0facz+&Ex zDV@-zf&c5zr7f+lU9>Pd*kv1$^f+@(DJ_~Mm4!7lG%x9skaf4s%s@H84UBp#b8p-% z1hdzjf`T!#qNcPxbPQD^i1xymwkPIvlXKW$gUEx+KQClLiTbH`?Uz;hVCHuYn1Xsg zo}+UIdWcrxpyQFi<0Hv;j;>(Wo~q5k26-oYnQ~TPs%&&PF~dRPR;E#8LkW9>+|$+k@)91gu zB^Rjb^R>9=f}RDYP_~}h;5uVUYr7^1J8Kky4o&jmB~9DBV9M!Diw|bT_dc?fgT0~B z756F0TM#kymv#B4VV-(t41bnLzW(lK*+}K>c*WuESZU9h!F#{^%(IZTq=Rf#aTV)T z5uf(BbtJ=O!-eDk!dHq{^N*P!p28afqE0Bz({_u8YkqH{!s!|ptOyVqK<})*R6}%e zg9TL=_C8BEwHO&nR94J)0VXhl)>EV$;Z9>|D~mxyT)g3&Obimj8}d?F1R-U9PjH?H zd-Fhy72lB%$6CWX4qsU8Of0wi0POMq%EH5mS z?$5Owd6Ew+hdb|`@Am5a%XkHl3Kx*f{922`UMIWISD2r6pRng5Oz-33ox5Y-_Yt*C zME*Bry=dVq~fNO;9<-49-AR z(OZoHF?1{P&<*HxD{J)5U#d?nHw8Yu^=BP5YI&rP$OSLK>=pcUNhAB-b*ETClXBt3 z^@^j9c6phgv3(;bBL-FwKE4H<-Wr-kAtnCz4-7A>w9u9qYq||DuLfq!kd&Ny{Mb0f zD=o1hr8BLO)vZ!Fo&e+U&ulFvi<+KqwO<4GWLaNCDKAsior~q!i0cT!Z_>`#DkR8O zkqfaTLaA?Hn{+m}#sB)4ln&pF2k}!7khv?el*%Zz|7R^~AIt$vF2CR+nNeWx!-8QB zOSbL7snEvpY98-mlB!RWpkCi$lCe(bN?D2R4c$<*O zN#0djRz96cA8I9HpoF_!je!hawxcaGT}tC{jHOhE8(WY(29CB z*)7k+qz=Gzy1KdOBRVA`Mv*mWq+ z@!xkYzhH-77BU(&xR2cSz@SoUmc{(q1DG#uk=^`HcNxRmPj9DAxCE|JnmA@HhJH%7YB> zUSJu_bV!-Acj#WX=;@-2KG-+jEyF&d`*eTCTVX(w`#i>58lc=DGuS6k?nJOz_!~Zq zH};QtKlD9P%JOs2t|8@iJmj27u>fJ8&zS$(felsF+l>=gH@qG8J^Gu!qlYigntxnC z<2zy@=VUGXy{P)%Q+?NTBKR4!J=T4t(|?rSrAJ<1y>WhqCEEu3c@OkpvPL30VJV#7 zEBxr+F^ZDFKX7}@_rTr}MEa4(EB){fq`*G{=!ai&c)24+d`$O7?F0ROkDGNNKFJ?& z40DDlyO#aB?UCJ+`buP(@ZP8flm1V*z_-D72^Tt!l&BIxQ_--WAh!G%D?(sK`(h3HN-$`ESw~>9BrHe5tD20d1kr5*v1Dze^UCPZ!-3Fl z%ivnoJ2j{MvDa_6UVlQy-)ja!ulZ@RY^*zFwE>2Q2ZoPqlUyo z(gPT52&klu9lz4_(uCNk=s$SsKNhx&eQyYp+%A09A}g~3Oi4-Zbc>#7Rjw+La(D>#RtTk6yBBhsE_tf7OjtOK|W zDG96cG|fEiOpXc+np^Gfh2a?#Dp8#rNN{9jw-G!cv;*nvGNkwmC1LLDQ!zPE&&qjq z5^C}a!;DZztPK{6PX$taa)hCz5E<9zfkH*ePho`vnd0eB4z&R_O6$%dDlD2-`6VS5 zW#WME2{bRQS(0kRq_L(!t4BQp}^h-0KM_*HaR;xQXG_=BiojUMg%z#tyr zcMQyYyX?mqaT8USx&dUDlL{UZS#*wCX3}d*iN^sVKEF8M*ENy!S{szoggl}ZNumtF zmI)G`iubw&)UX2f6c!x^rOd+OtH=S!VI^gDGS9HVE#j>}(kbAXENr0Ue;`;Pb_Yb2 z91l`zp@}4EVnkb;6s%smv$I6{WHM4f2cf0{aA_IpL^Z+fgLM4=;zD&LM&q#l91?c)6a};AKI`OcNco;B3*MH};4vZUFv3 zTn6lC1BEgbb?tgow?iDD=zWwt=x&m;BRPq*Sbi<$dP085?Gt-?1$>gF$9Go+k(?K?&LiMVzIw7$m8|(fHTjt~f1Ao3ueb#9whbjH{>ai{mwlm?jhS}`-7%WcR0g9DQtpN&g>YHbrzM89@Y1{80j_0oy-4gpd`@t~9`DdnU($TJDzk3W@ z62k<@ko=utK)XDEfe?gb8O*2`k@m`*P?q&7&HgKGwYhDWQo-U2vn^=Hx}|8knd(UW za$2%2=SJwL8`-ySz~D~mJh$($q{9V-wTIix-fP4KX;8J3F+Zvq1m0CkXm~*l>xq2f))u$zPm%Sw?l*Ig55$FxW4ip^uj<|!*-msV_+ zrz^_TVfW(XnN~_tMw--BlXqNh+%TR48|lubY~tw_Sc?lLW73%!b1Q(oQ?PRm*K&@B zz>Q)=H+N6hz7?nrER)cZaY3)X2bbFt7w=ktD@wX`_7x8ZzaF1JnUElX%)ShYnSq4) zd0Q_$`dZ-vzb%zyHj7PT&-DdL`Nkud#AADOmi(E0&u6cP?khVHx3?pAhlkK7UCZYW zPOHE}GAyOi*Wo%{kWtUNjN;sX-a=xiJy2gs$*E9UVImmzTfh6{O7XzXy$Lu@{m3pk zFs5+*dU>Gl6 zg=Skgq`*&z=Om0HAF)KkPL(q)J~cH;s$wJ&X}}1!EZcd`>3nW49d^JO%};Xw_9K&h zq$s>N;Q*apMYEH@?1|%j!%&JlN;dT6_U8uEaTJVOl3ECx9~SacY}_sDnJXf3_OG#8 zKWJ;n4jpUJyI|9f)SmB;sbVT>m0XGOtb<-t0pm+F@5w2R*1iH6mm;W4lb->Ufx~cBY<~rEnt>uukm&4( z$XJxG@Rq;ad|$^7ob6t!f5`?eQHmEu*_K--Ld7xyQ-G}mZ|ZxRkQ?lkliVY_xCLz3 zIY~KAlrU$~khS#1;qV@UGHI3?qxRSMXs~}RjSD_-uJOSZ?AC>Bl{Ar68vsrl!d4q3 zqdk4T3xzBZ5LF)*`JDOK+72#Us{4K<9oFxJJXctafCxFFOc;RCJJw5#e2 zqB!PSO!CIN4H@6|CmCiYs2?YYS(<0uAPJ~ydN&?WQ0~pE$|43&h|vXmy&6BB4tkp< zuvt?|_%3W`Nq487+F(cY0fz4|7)4uT%C?MT>`(=afCmiHlTm#t+c2hWiCYWwj*=aF zUR^MOZk*PGl=(of1E_AS+R>}xszMRTftw`%J+VO#4GO}g+gyZ3O{ab z0{#7Bems9Q;e1`u%b(xXGbHi`dC07@9%-j(UD9%t08_-y+FSdp-%M;$LUfW61D^p` zUlC+4oZWL|Dl-PH$Ao!DgzCVtBLWnZkM0`d zxLUzBX@eleB$L5n|8F>o3tYq{2!kL9gCy7^_um!*=tu)_=n3xAKuReQuGQT z>PLj}m7@O)SUm`Dfa?o_{b2OSn%58dMtMCrw=c;J`f)GS4#;J|7x7EBYZwjh=Xb^WIjhX99ZVknFG^&xxJISGZ2=6S#(@|{#Zh3k=QG{ zTiQh!*WSIC&UNJCe3mQ3v!G;JRJTRQSbn_ynP}YyK{5ko-IlXtigcOUeg}p-OCj~W zGgvMcVE2>6LVh%07!%s|B>TAX=#V%m_9#`E((!Zvr6gT4wFiS1rGJSeW3{5BeiRdE zW=aKuQt7~mB&K%hv_E!A21w@yNGFHAd<5*%bd-0xM2JVUvL z8HJVUA23iP90qh76b0u5vyT$LLfQ5?HBclSkOr~0cn!1qEKvp(%^dyK5 zfG=i^lYO<)W%aMlm2|5mZe(z5E!~g+9dQMK=j@$}tAZV+3~+K?B6dga_W0U(%r-z# z3bsL^BQgpF+mP|e*0Jc{Bu~2ls*^wJ726in;j5D;H7TGAR2m31@t_Na8VEB9pbOEq zpbMM6D8k>xf#*tZX)U16xh73Qhn0lDnTgF~#oI>ATZE2}LNq(})CR4gFC@KN&y*_p zrLLPa#4+ijlOay^eq@@MYzy2=vrr>+Qo5FIbvtHkhhjD#?J3HfL5{)Ejkt>`a2TaH zK?;+^46+<>9g~n0DtKWUlXChIk08qwa)X>F7VLT+V1FpdDFM0(VjM7ZWQegvGNLVv zkMdWU8nqX*ER0EqA5aa9y-^U*wS+V6e%p8}piw5jFqY9U(l%xY{~*v|S*`~*}#9K}l&$>{LxrTr{ja+-jeZV1c?D@H-L?G{Mf zor!nVR1!OiNp6vH*$<3~b)cFsf-ew$maD_u*3(*0_N$LZPX?}HqjnNE<55h1k zW)JfE?omBw7*mHOu^6ag7T>>{LpgOMQpa~JIq(LRkMI;qyos%hxr@)Tiy&GPFcr6$ z<@uH}3=2|8J+`SmIIFx4oOc%(oSb}N-b!A@(z-IA-Iw(yO&lnu)LRC#P>p3B9|kBp zrwukUWqnkUy(}-U$V&JVkb#f*_J}VqCsI%nISdLSSr%vG5@-2Du?5-;U^?lh8LowE zGY`7wsXdFd(WMX1I-FQ#8cFy-;X)?mrs-W5|9XEc%Wo59(clT}y_S%4dqM}v%Y_Ci zO#2aBFpMjP2C7U2S~-CpmlYUfUIwjKz@1hc>IHdlXI07jIV|BombKSQbAQ)GzU|_) z!PLu!?V7Zxi8d_gS&rx=wqI(K`#m~fcW9X1LQL-9#`n5r|5BPLZ~ghoF6){dJrk^rGg>DS*|>6a>B0ti?~Wb)`lWl$5pZPC`8P<4BoY7HQXKJao% zFUdxIG9jG=GRqCZ{t^i3X2S(C6%TkQzs1Pb&x*E0*Z<>$QJEdt;&xS z9#snR#l71khWHCvPvbT1ey!Fdvl%{-mr*02Eq4nkBc`w+1{V`VEG_#^Tx`R3ruC*T z+`v2uXA4>`#mwMwfyRWzv4tr1@twyIa#EoUxP~?Sk&dwNuusyPz2tcc4#|9|sXhGk z28k6qP+Xu#rb9ll93k=6lxQt1r&ZC8aX-#5`lThu{!O%fPs^|B?-QhEZXaej(V=UK zJr^N7vITwDVVlLwM*ZHGr}q_eFZBfvzPO`8psr2sDDh(#-7$|!rMZgGo9^bi7@M00~? z3mPtz0Q5jhm-)#xgZWsS#i7+D7eW9L?>BEF2Q_b4TD}3LtoDnyTSjwi+{gh5btQfn z3Ze90ah2!yUhC$mI~T|X4N3EOSbm1YzU~=u^y<1=YSKXH^Zp4hfl#<7R~OMA;6k4m zy#>tO%D5sqRilK8L6=!*cQxF+I_yU6>Be$Oc$NMCC=r_&t1oRSy-Jg0^M+*9YV_ul z(iaDJBQ`zAzelq++F7Lt~vh%u6* z!d+ABt51+1=`EK-Bu!$fphq>;{te`e(BTUvnor(n8@-oA^7I9ZvKm?2-V4u61B?P0 zi|?IsFh}%|F+)cytChTWQu$G+CT$R39aK!KNmhk?MEN?JR(bjmk3CJE=naTYHd}W& z6C5QhD>X&KdvTPoDHQ>J6UlE2>g-v-yC6s)T#G^goGPVYM0Kk`#2pILdbnglZvNz6 zSycq5tTs!lC(*w>&&_(@a@8l_cQBknaleYT>b6v#7H8_Hr_Fi-%#P>Y;{lSEaN?&x%@{yk9LKz3osJ2xX2#@NES76IJYr^h#4s^jE!}!-rh7@G zDW61!IroEYW=^|P>7Gg(R^z8LY}bEd!{9UeH>po@i@k50NcGj=40o9&e^V42yK~$f z2qX3AqP(Pn8)|9w0VA`M|C;%dbMcLhviFh5>{4D*@jYwH{NDunV{j<_(qa1+&smqi z_qaEQ5QrRDe)^}j0o6V{p)KiGsd!Q~eK4{PdtL>7sGU9cp$)B3mj*2Qx=dC>U5HH` z!rY?9FoZoko6SYB^afDfvSp=*z~u_Zkb!+F(#j}c-iAfwcQ+xjpl-i{<+OIUm5tih|Jctda2r27kVym|Tz14rOFp>IZ z>aw8eT$80htp&b4{=P8i&nB3JS2#F?8tVYTWi4B`p}%DP)hx|_J< zDtU!JS>E5UA?q6(PL<_k(9kKvd@2@I(jYN3F|j8^+8POM{k-zg;VIRntj2q*D^;JLiPbXZwqy{F0|YmUqj?xviVAB4Y!j(FooPj zb2ks|P$ZPx(|&4ApGnJw@L;n5jLX*v#BGl+&vAh+ctmpyL7_dZpdw0LE&+mZAed5M%)W{WJ zMQ{3B*e&BA1`T#FfG&(L2>aN!QDak61obvhwoKV%k1Uf7F6WG(!Z+-i-mO3BTKS&~ z?{r(HKXaa6;w9Y8vDBBlR??}0x{F23IXE+~TT0T2_AC4rB{`NE|Kgz@LU zSuo%aY(79Sfq*)hfqU7Ai;Jh&3E>NYK#3x@vXi1?1P7Q&MVOgQj7)|_y2sX^dbA?S>e8;msIc2((y!wbsnxc& zZmnOJZmgfQZPfYOx7&DrAc431+-&k%I#7V#+rGSzo)q}raPRyZ#$Nh{Ik(@3ut{`C zG;$vuDf}h-;XMTwPrC)WVhrw0p7{y-Zb}K~5xt*D13pYszqiT?Undk9y-zFsz7Pol zj*EW|FMj*02{C@0Vm`_meA5y_zq9`i7;gF5Uvu<+btDKFAEp)XNjErHyYYS{B>2vZ z6uiBaB>am0))Q)2((dyQjpUT)IVrXAsScW3()C-xB7kKHrz+AZzAM6n67BGEdf-Jh z3xlMCatywW25F@E`;AnNTvqL3Y2S;zCfQ(pN2!5=vGU1}A z>ga9p7xk4LZ(GT*)z#VHv|GXU5#A2o6B{xxg&TDo97UBK@fd|z6b%8?5gi#I6Gm0$ zf}gQJa2l)IHe=Sr@a%&&&F$%Lm{!9tTtV|upGiH73DcsV_GMC;3Z?78Yd9r#iS>i?EYXLztLQ|eDY#UT0 zS^j*|BTYnT&!_Rx?&23g!NicX$<cehz*_yoLw(1 z5mw3g+OLgj(S`4fY#EF26qT)Y412J)(nte$ouSHZD3>*M1{M8vB83T31!e-pcNTmR%-k@mRn ztsMw|$1C}Wo?u<+EMM)5DyIHHr9#&jTFX~S%JbWqj!$Lbw)h5^I?rjSiXq!V$~mq@ zFW~Ab8eT`(WF4Fhfq$e<9^J!TY4Aus+;9fj)w^ma24+=DJnik5)Ck1;;urcPK6=1A z3qRuX2%oCjhj@I}O=YfCrD2$LWT8RXZ~$^~RiQ&gT47&=?hMf!=UF4Q&6i1V)x(lO zhM6E^2R!c?hEKcUa%^}-#|$Gz^eEJHKvS4uU|yss02LuuUCh$u%So}{K2%0SmF_7P zLLeZ!V^cA4DL+c{Kz+tb;%gsfA!=Y3b9z*yUyC^B6U}sm5OX$wN1S)Bl!#1&1*XQ! zD)?i0e=WVIGaVr`8@5XM+=(;+mCZK9L&>t-6ycBD4*HgEGIa|MErx!Z*;>jpCMR7V zh{Zk|zQWh=Sv|fc3H}oTH&lmt-F#T|GX7yl;gQsQQelKO=WnDJ*@usj4oromh^6B$ z4T&6BOO-UvHT0{Az6CcF4vZctyJ;)Qf)7k47UPI+u+`XH@9y@Mw*$QS2c@@boFAbIV{dsaoh4Gu1-Yh0Oepmxo7*c(i= zIaP$?XmbtxIcTT9M3PEsySglUqRr-YpoXcJZX4NnyCgF6J$~Spee+gjrnL{*n2gwF z?t{;x=JooVYC8F&qqdNWdS^Xudilvs;I+*E;=QhpOss?q#wuw>ZQKd6?=$~+PhZK~ zLDgZhhJibR>RkJ@qkk6ZrhVi8v-~eS8ie=jbmi!&NnE+X=bU*K*)B_s`$rxG(5E}W zWj-)`#4sh;g02wFnQjJko3BzkJw?R&lfOf=6r{;=t{VbJ)e|AIFH+2Wu84Fc)Q_h} z+qFfH2#4kVHF^c>9C}|mM2IY)V8x?*&L{hg>93f|DcgqDgW8%boEf}|lLMA*Aw(ij zGDKoZIM_n3LQ&Afmc!>!yln^ddQs)yKS6==0Eg!SvR3Rin4}JJnlGcrOF-g=_gt<@|E0do91)J8*k;!!rQVK&7@ zwG9q>b-5HL!VnpPFl)adXSET5U%K_;Tf|(!v>$&D$E^2uslaov9_Eo*Mxp8{s~wPaxH4pfg9wI|2ojAZ?SMaBU zFI|H!t-Up>TQ%~J+JB?uHKTiVnco{Dd&gmsqq2xeSie)HdDT(AS5!3{qeUwYXF)$Ga^s71@_`_qPP1Ol;lpPd zOfRpV$}uJ}B0^)W?e`?6KnKLK@W6Fz7Oc^PBZ>hvyXUftbeLPprvFO=L85)6{Dmxi z`XdRnnC>AxYE6t$^r=5AClK899e#1xu{yz^xcrf(uIw+~f@3<0&3{yw!tgbDTE;@d z#^ML}FVkz~^R>-D7`7}KcL5tGqJs9C)qM(QM9vBC9yz%Dc zrTp)sSik77Fk6j;*l3kVeMQYm`AXe0M;HAW`|efWwAibEvC?JD*kYcc$^=XaD$WrdW2EhmAZE}lTdll#}C9hNAuBu2H=k4WL> zVsOr4Bcu%l(6PkN-?R7WaB&FYb6_@P^`PBqd<@BKOu>aN&9fM|HqS zg!ZV^|3K)u!&`6}4V@7d?FTtW^&9~|Fm*nfLh3nX5aMW49TR6Hb>J#(f>LcurjCAC zx4jan$NE}#a!JW|IHJEuFZ>M-ws~dRD1ctLActaDz4L<($z4+|X{Y|vP|{r<|8B*- zMJiqhN9jk{OW5cxTPh65Cl*fn*)@8jq*t;~$DZXAO1b-Q1^agyg3ld(TWWyzt{SGJk=_WbCvwlv{CeC< zfnLtirj&O#IGZ>^VQ@*Zx^c#T01cRR_ljp1II8siEX^r9x8^#?TCTDAsu2Z668MS| z_=>c#d7O$!Al&QGT5FwIYyE)DkWaXEzeSBPVd-d}+6JSr^l9IEolZfiolDx;IVWWw zdp+{yW7O5H(yQPa*{~Qfwqa3n^l!ONN0%c6pcaFX&!J8&77~M-tQ!{eTzVc7xE=ON zA20blUrC++*6uQYxK+mnhAP5v4c-OPHJg+>j17=7}SVt z+$GAs$$Qb_0kUr5OTy9te(gBq>58nT5i)IK2)ftdk9KhGfME2EQ1DJTh+)WmpQ7*` zDAjeO8hL;i`~J9F_A4|!s-Sq*D|Q{KVC23*#nry%GGl-!b{|*u+_@)LfObk1J$mMcH#QF>Jxz z!ZoC70Mg6#@)ZpBF!o~~_Umjh*5&}!Twzh2q=?pRnvOq3vF#zcQ94&phB1A4gPcl7 z+eCvWQ2mm@{gDDPFTiAkIQX!B3^vWXn#|3_ydC~=$?EfeVPM}{gbe1tGIb`^kCrvo zd-^Lkjo=b)Su;7KVAk(hpP)?9buqz9X>|EhEa$IAlWt*&2Tk+v{w zuL)+C28Bjp6BbvmOIlZW6b{>4P-9qBk9|kIUjzPpU#lW#h)WDw|JwEou_>5E=c5ID zu9gn^0!pKl5_trk)#83uRl_0?haqc2uiJ48xV>=-px&cYnJk-e3i2HN)-8>7#*2?C zslsf_pWoWg+>fcEPv$Alkh29W5^N~|at*E+#G3P^k67_P^}1MXypS)_Foc!Ph6eyk zJQmDfj@G27XY?fS&wsfBCF~~$6^^`!$DpHGFQ1;WDz~qS^F;H zVF4`|W+OFnITaB34vO3e8$Mjfm6)J?xQI=N>V(+K251^{_DAM_0|$LZQ&UcWaquf{Jc>~7!y5%aZ@xfh^JfmH2+&Sv z+jMQtm9kcg>tqHawdW;luqD>LN3jns0B~MbO@j^Y<^+RfnYI%X!@Y#40)oB*N*BsF zu{vr{mrrS2^F{m<;{MFA0_x%&w0SVnItxjiqi7cL37C>{8Ex67HzyY33s_oaTvIUc zNnR#aAL9BLoH@y^^R3RL5sUD1B`O3!A#h7f{3+7U(AA1HRni4AG0q->yxHlOPL_E1 zMYi5S)~o+2%NRC}v{ z6_wi$yt}eIZkONo#|kh`gELCN{#4rUw5%kq`(#NvJm9U5v{y})q0SFUFDFq^StQ*3 zRjlb~j2TzWex-hGp~|eKjYqf3S*O_j7^P0o`H@2GP~O$#wp z(eg#JY-c(L7*0;E>LQ~&mVM<{xqTDcy4-`QQ}U%oJkQ|_Tm3UASE~`x82@6JSH3Ou zJ4il+vV>WEyp(K3ULO?|GEs=!Z>zL~Bw~dHlrmuGsnn@jIysJ^T8?DJ{)Cvv3+s$N z@MAza4zpqTP8CzNN>&<`Tm>(awX(%R$lYSM~%zC}A1abHq7RMo>N*7aD)1%Hgm_Ozk8GNoE%1(Fun?B+xmi z&=;G2f3(GcP93FM{bP-u_WndVJ4^x&ujV_&@f3<={U-~*V{SlY-D%j@gT7>$*98@Q zZ{w7$T{`3@apja`b+OqR6}mpC0-PXVQAdM{;Xa71D`+RM=u^;EZ`y$Obibi#YzCZG&$1j)eHQAAY@w9L7Th}!w zhr!20`kc`|s!vP{`sr|}M9k+u<=S?D{{qnOheu=Fg$$DzOz4cjBE)(L>x`657Jad& zhy6eaWTn>KQ+8Asog(XC(rF`TDJ;dzlFL(8y{#eruvkV&OsHSlG9VI^H{ZJ)WH@}Y zT+lOWf8Vasl27MKjs@s{iyM{_*F>_2W)cdU!{)RSyv-{0=Wf39s}=PZQd|(06$K>O zJSNVAdLkzzcnL0cvZEb$_T>i8V8@r`K&T!5#9R z;nm+WkV5R0ymXa-Q?t%}L@`hqX`meTb}Zk(K2GphU!7qJE7H&Z?yEOu6aDCHhCnw= zej4~4wQvi{pC=N>1;DuYjVS}@lt1a4a8n(yo!EZ(dVY?8CzL?7r;IjtR=yD+|QnnfG4wFBRqmm5(t^E`D%chX!@l>>C2^NznXahM2w{ z!l?lIaglW4S^>}u-D=P*g$NiM-Mz*au7f$7gp>JTJv0y6!Ow=LhDT2uKmUy*$e8!q z|MAb^%kmFq#PR>$q$|6dyPK2!qh(9GnY$RfIlBBO2v+TXgN*o>9M+oYl={vg1B!^+ z#I38Vq?$saq*24L;G*C68{^EK*T^^M2Qdx5u-}DDN(7A1h*M5enFn7p<2>77(-I+> zavdzMH(ihOd@U_6ZrX2v-klpTczoEF4`L!}PSckFc;;+4Pu3IrIWYn73o=9Q*nP$O z6*0i*?N}rg{InU^TEWF*xvaAK*b&#x|0q!n1HO6O{gtnfJPnUxK)kgrJvOqI*LH<>%wXZ2O*LW@YmnU|3j z2T>Vb@G^xNSKFK<=?!S0b!G^xAL?mf773iirM=+3q7Q!t{%{-QAWe%QDUcO1Eh~C& zdff#vI$X4UjdGY2p2+gqJ9kq-iz`cc)#()+YiPfMsrjpGnFz0jS#O1A=Vep!qp+A` z*k7mXha4hMsF9fe1}tu{L?W#5D9Wv;sd~UW?>yG@jhi=!omz>sBw)b(nmEH6vd52) zI-8hQrtDJNTwsnvj!4+jr_8HvX6DpzW^S{K64w^T_hkNc0K&jxmY{1Hu^LcF_FAOe zAK?b*N@xatJBc8caa(51HpSZ-VrWzZ$wffR%;_N0<$22^E}+8OezQ-gJ(R+Cf2ah1 zT&UDVjDQF`Ee-%`%DP0`0%J#W6sGOnu*!I01)~4c0+FHfFI;z4BnmRyh?YzEz>6G~ zaslC$bW-AiE3^ezGr`5IOd$Ooq%HUsCvEv0A)kVJ)pxlGQJ~yF8i5LXZqH9h4Jt|} zTC&(0>e%;aTBA z2f(C^B7{&-v{8gmP34GqP)bZ8rNB~9)cj`ncC(Em=0s5Hy6x>R{^5tT*qy7b?bmZO zq|n$`*6Ft}yKOcazE%zUTN(II=5jd^ErdRqJbhn2fB)q9UUyo~1-_o+0=4blAn<8{ z@e=GG({A!z4v@C-o|eW^Bz8GLC*0p_c6!eQkK=P4hu}))dxd;7I6shaDt0QxRqAsk zpepbk47GU8fd`*ppIjjH><-cV^WjMwd_yGmoejh?EZ;Zd?zrruz3dzx^NzkU7|@Ja z`z4|W?gVG*uLfZ|Sm1LVjA&!#Xl=E4jfQJ7k9++)o`=)X$u%LDv-1s@(~Gtw``-%__A?^_YB9!#wb8yfB7#WG`EJhqvnmuQ; zQbGl1@(IjGvg_0LQ$IME7}tB6S}8j#s+`35$4w6LgEU!7O8&fwYLXC1iGqz?PG98@ zDTw%j8kq?ZcWV?!wRmb-uTj>&nE2Gq(LpW09(nx4@e&(dDvW3=VhK4wGW55X9)B}u zc{u&PhPP+XExgLlqHcYB1IE4GPxl!aNgW6@2$@s#4%LOwTEXUco$_N?3m>OqWJ> z%;%G8#Lv{ZJt$1SCOZi5F{`pFNqS}A!WER0u+XdK-h9ku62r*jP0QTrFm5zNQ9+&} zSXHF?7dbLwrb2BFtmNgJb)TEOi`|G;7&_DOcm>H4-XxKn4%>Bgz+pFYZg`E4`mr0yimw=?}jZ{o1J@q0`P5l=M_lbvVZGo1|WC zynAD<)AT(lO}7@DcCx}s6P2%&o=f%R8|Dzh`WAAd#t{$(H~+<&{hINx&Oci3URIKl zCBs?Y*Z|ML$@C0>hzFEk>VV~_tt5ejO6?@u5y>u zrkjavO<+PR3zc>P)#Xgywb=oZ+3C#9fNG_MAk67uipZ(ixo5ecpp>9zD@-})%)XzP zSowPIL5N_jdS=_=l3XJ-$9%8vPtp0ubNOKy=@cFg>{Iw5xN67XW^CgXnN!f?fCA5q zLeP1)(%}>C1l;EF6o9iZ`~(Z!{+IXGl`|mNuH$(+ko&n8}E5nfIE!k zZkm^ijOQeJlsq}@qDUtUDNuJ6jla0>ZweY|a@HQrpqf1j=0VpxJ(V@*s9=2H z^xo@!ZXvv%b=>C|rz%FY^DqkGMsF@;EEbzUc_vLQV>MaC{LGNtdNe%**)G+!o(a7y z&U!~Vp{8d(!fqm=(eh>unWjC%og!tEI$}VvqGWd-C1=150P)U%g0-y@=?R17Rx`zA zC`EDSorO`7dce={hUClRJSs*T*`?mCCqBXw_V@!$reU_TJJv zeng|O+~uNwfiRoY7qW+pks4-abE)*)SA|mfO~nrpQ>f(Sh+ORT5PV4?TAxCseijb_ zmH4@c7jeP9TTjfTJ<8$h|2F@=HxMLNqje!65TyM@I|<{UR`J_%Hz zXHJ`ZR+~Il+g%jmjs#Y2Q|1bqo@@=R(k-$uEy5$LFv!h;h(}{#UWSKQt{ayTWrcX9 z+zrOms4iWkJtv}X1NEi@6lQa_BVF2eo_N=M8Ub55ZxnstLlPi9Kt^kbYHtIBWXn)tKcMZy?>>O@6ZysD7xpa_cJ3Y3m3^jGEpMyA0?SHRvNvN5=mBGenN zCX4VR8Ue7zAv(Rh+AOI{o_I#hvwOfM0L)lW+~_w~;u!l@jjYPRulzZbp`6$Kn z(IfdKNC(ps0fGsxx#F|_A@EBqGgJ*Krbh15k(p%1oJLRT+t53;&O)Vcut@I@AMDO} z^A~6MNg$nF4V;)S!^S<_26O6_zl4b^ttZ4+MO&Ml0vY{+;|NEw&qSpjW6s!?u zITi9z6&gB5K6`~E4d!{RS^jXvTxi5x7oHI zXPPCv3CQXB8Y3;Gi!Oa2ioLy`%{Y`af}w_}eUxb4cTs(tl=WiqO_20W1bs$;-)mg* zwawIaMa1GHJtvqZq!ahaN+N{G8~uY|AWioBSCtfERUb1jrMd}NFW0Tu&Ek!rz-MT+ zG=ttedOUS3=4(BN57(GWxDzmna{-tC)IKW`tPA#KFeJioDHa5K>1o1%sGF{Qt@?3* z9Dn5LurVGp!X87YU26KJP3R@9mDa>#VI}5>a9$RLGQElwS|pv^-)y;DxeED_i{tQ~ zl|_&*dzRNtxgok`A)ddG;?uBN?2+)Ik6QXzW#oUEWyI-OwG>Y_viJ?N9Y*ZKJbAZ5 zd7DHw#rOOX&qsPQ=Ixk7TNE_Ltw|IRW_ch5WPKfG(;(6+E?L5xu4E$JgergIZl9?l zSlSGyaI?XCM`=%U*Mqfh)Liw+kn8i_u3>uBT(zyYtd5xKw)U<}AK36_#x*zJ&eqVi zsb)ht3$EP)#f*lcRU#IP@WC~Bp|4B1bk5)AT3+#cIe-%*Uvtz-6;Xatd<3eDDhl^j|By@xUE z;oB<~uXZ#bc+ywXIkDMk#=BDRBQTs$eW#VRZaXj#eU0@F|98wcN?)F2hmrNVN>&L= ze&Ka#Kggz_P&sA4Zb(W2zOM3j;D4RU8)kq)EB+y@I{t+~vHp)!`G4?A|A9*X??2ph zjV(nqO|+lc?KON4Y%t+lTTF2A%(Z4%S#jFNfS@T20RS!0>aXGJ4&IKLq^-fMio3~2 zQu&+;M~?W`wpogJYc^^rwm*^2lP`UbiKpF+i>{Ut=HRHzVZOgNedpf3=Kh9bHWcuI z-U=L(<=vU`Mu4malVu9P2@Pm7z`I(9$(H(I!_K=f1Us63BwFaw8@25x<@P;Pfy!eYXNlcj~KV$eDE zd#ll4EO2F~SneqxuCWFdpsmDw@q}6Bw8Lm-X4hqcXV2hx@TQ+tk8LV5hOZvglWFmh z?oC9h3kw3>lRs@&ghGOxiIX@T?kbLFn3=T-hdq}oP&kjA1>_Ve!SeigAc`wQ{(~5j zHEGbNW=%^E&%=Ovw`wh)vOIenexW~)tn1FlhOg)iF%0*@@A%TO9jZ;5)dLYruMNAr-2Z!InQcucg zqzJAJGW*N>S5kR?SN6(rKH0TCtn;!QeVJ?J{d%5-mN_~$KNnrmLH@d!(AK+|N}%Hm zMMKs%wK-i;#gb0)aeXSq&2EK6wCBzW{Af`^%ZKY_PEdu@{p?q3%*yBj2WQ7py2hQn zOI|%&tmm^GMjT1%((z_bP8)>FW0`UeRT{M0LTr0z!BGC~(6Ddlwhp2rj4xs*uREfW z=J-c+-`mn!j6dMIvVqm@rnpxlnr^6+4?=a7WJI#fIJZvWuN_iA#=oZP;IizD1Y;z- zStq0dcGIcw6D%b-pe_CeT0riFxp%P0QnokI@@+JP3LTSunz%ZOQoQTW=0#F`%Ks{J zyJI0@eI!T@h@v4!>*<2(pOy5My3UfXf@CL4D9VX14$c=vO91?a^XQDUzFzx!!n;1UAvT^l#X+OoiJ)>R20!eYV(qA z$o)>?CN3z;htwB!e!CVykwsbyWsxTAH*4Xjx}@qV+N4LXdFN{15${Oo&${?M{l!mZ zxpQZ#{(9FH045Mo@4U%guabeJCGj-u{#>ZOs+oS3m^Ro?w9@m-8G&JYSfNtu9^VFb z%$8CGnh&vx*JjFGjU=&&ybHsbl?+8tlK%r`V@(sPxnW_ZPnh-t1LmW?#B-kkG`xfB z?54RFYL+Y@sFa}^({046Un*%IKhHdG^I}uVWV$M!uGl_3Q@%zJnp~zHjMR>Gp=ced6Hng z_>z1B;a4H55a-v&g6#|9T^$tw(L^_vY{A=*yFSzGtkmDno@7L>Ki`DsE;bv?UY*~h zO8FBSQe;q<-$1c!L3U|zV0@@S?vBK~iZ0QiC4F(K-@{0;DZa$U&j5i&;R%9N(M@+a zql#e~Z58#`s47mPAa$c9*I>Z`Sw3P@Khw~68>lQ2clcOQ;n3aUFpBHAG2*{is&;;% z1BWPeEN4`uP-46m)Oqv2*>y?5nnTXM9#uCwhU-d%UK?(uQGvc6)|y4AOG{oGVX zm-AJ4v)$>MDwo92??kxskoUuV5;*61QsWqK&4*lvw7{owmg)C~ZWvIv;K! zrpbthv!D5wZ&|kgVLosn@F8pG;Ruo7o%Cx`^hY%C_;0`0se9KhvEUcu?~YSq%-%so z$9r=T)H3M3Vwd-PU8)XP$o23kMTNc&J~aw92UlB?#2bRXLsQJ+2UX!dDm3x860Nk` z^0W<$yY-|R&6zn&1LZOMqa@*(y+QOOSv8xXlVSN-R*NHl=q6ta5UHw0vukAU* zd_*=xuC_Sc0FDkfQ1%y?WFjFjJScZ+Ja~#XP~&4H2wHRTWAep)eM-MuIWMhlwzto+ z1_Xt-m!(YTI93Cgkn!yjM^Qlc+}M!EX}ZB?38Y4r_N@3?sdHq+4~AWsg$uMu_&Nms zAwE$qz|qM`t51_B+K@LTQJRE>$v?MwmkZ<~5T~_~*4*d)lsrU5JeO7Kig}aq9H0;> zQSY3Fg-9@B;TqwpA%N!572+So7h5^#G>oe=toU*qP!Fqgdqk7gld;0|#J3i_$}BGj z;*$^CZsVB&X&$15s|ijlQ#Tf+IRw!nG2o89v>qxKB0ZvaRxHdpQsNN2L#2DcR_~2O zmikuwo}ErRqlnkQHHap4nVMARP>3K&&0W`Dd;g%NT3iA%ykZfglj^a-O%FxD=e2lW zW6xM>>^X6GaTH@J_}uU%1W=U@Ln;feMu$jX!O$}WA$@LMyA|?#%GKQxA4M{30!eXU zs>!u9Z+8>)Yn+-aEFfRV!B*EPiUn?m169V7Bi(o|M9xSTzE?I++Z}{hGIcVQoT4*c zhe|pim?lP#!6U$z+1FUX5~u7OvxIRYBxh0+O5&{JLaC=lWO&muXLGLy4P%K+>J!*HQ@5h))NP!{X0G#Ov$ zLUFMa3ku=Dwti;oqPch?YcfGJkW2d>V==KXyT@$A*uIO-@UfX06U=$E6tcePf>zGS zZ11C%Ff9Xjk-4-&2bjLUHL*q3c*&6^n{Z3fdfr8mZLYxgm?wFUXRJXIIYUBk)*{@JLFbJ0V4%)up( ze%g0HEm`eXTT_$re95#6Ts>WyX#85|G!A92o_99v)&8wA0{!${Z*$X`OD`*1_Sc4^ zTzM)KgoF`0cR zFrY-90n8+YZibZ@g#7vgeUBvq`PwCM%B|w)r>+hSw=+QII~(%iC`6Mo<`&zprCGL$ zrS3C?{O=4#N6N!tZw~OLJtwXR7_$5)bm1dbv67;5&^^&_IpibBcorrU?8nHZfVq>p zu2nK0Hy=WeG1Ufz!pa9E1G|+o4UIN48~{&mDtS-p^My(5>aV3OHVBesYB@oXu|ML3 z{y@#K_O&n)gq4tkeO;?_E!)yJi=zllsg}L5l|kYepX!&B69r47?vGqh3YcGXho9EB z0Ln<=kUIc;F*xX+7hm$T>)|^pi&XBH-hTP#Cf%?aYPVaH?xiu^^N{+*S64?tac6Mr z7Uj?`y#6ND5RV9|NA;WoU3NVp$a-D##3t+LRRHQhnjp@LY{5Nc#HY1WcHv8`m5CJQ zu!&fu<2M0@bu9U#H#S4&u`>K#O6+-Cs2+r`fCA@WG-yP}lyvV}`25-irG_sxK@WU^khlDVy zn_bJzOcVGrRy|U$ZkQ_&PkNz(d+8iOCrw0Bk`%Y;A4_cx76k6%-HN{`vI4GQ@H`nT-#P*DCFdtw|M6j z8wXeR024a2&TC-Tt=}d9)R&b3?5P@l*#e;_>nX(L0t)_JF8PwxD_&V}%j!mHc&|Ua zHZMEwIWf17X(w#lAc{$%+_IzE#vn+MRN%%-tJg&6^Yl!E#59$|Y=sF*{JrrSL_6*C zyk(8FakKQsy8lYv_$^xge87)zbfKmskds^v9EVIvOaZD?&<1)xCEjy2?hp`%R;ldj zQp&wHnv*BUZT<{t*P_32*}G!*u_CTY8Ax}sQiU-yS%+o+D(RFbGgj?(4uUwhi%Ts; zd#GYMreeZ8;9Tq|cE>Mtgd|}NUsWkx-IdAq1Xi7pTDx8G{%~%T+we{|Yon6x)6fOz zpY)EK>QR_+;Zg8Wcbj!kQIz|{%kSG3`avaI_P+(5IsOqxBqo?k(lnRGS6OUTi@PXQ zxdWBsUH!P8Vr2G7)jp{mS9Q#|Ip?_jlhhFJb+wdw57nMPDlo&g!^x+wJ&2668a>ZK$@j0ye>{NuDu7c zkgHa^uo2cFRX(H|f9BX8^2xy}f?Ix9U+bSr;}p^<=EOe2mJQum6`!vFo!bQKl>}VL*ZIpD zrwP{fxRmkA_GwT7cnAM-o@Mh_!980II*lYw?D}P`6Gu0V-bpT-Wa`Gnv(0#Q=g^Tm zqy3a>kN3D$GN+=>TB%xcXP*SMJO%55_OB6UT`@yCP8WzIZynLz+TpotDOIXQ-Ay2Q4QULF+7Riu4=TWZTJ>iJz3Qt!@Ay z^gD2Xd^{_0i6U;Uc?NVNVQiyxFHIleyaTqKs9IsM44c?4M{WfLj!>r*R2!eL+!!%} zbg29(F<>_OvbU13j3{k@o|knwRVjzEg1!lYJ(9pW!|}R_OpA$4W%;@SYsFMjSzOkA za1#9O38_JR7R)?~t{i%*PD*^a_)uu8vj?lO1BbDP`mYbab_HN9x<=s3l$un(uF(U(oV+j{-Dcy2eL;yn5o|o?pzMP}5&ZKv2ruDYN+eVjbm2KO$ZL`a^ZFboo0R= z%v5$mfsMe8frS&~5smz8NMR5+5uzO(Q5FLZd~3nb>cUuc z5uW^{S7EFRcnfMXFZ`y&Kr-LTM{Djn(|axar+JS;ciDlkABO7+zfXv{)SsPP$!s_#qjt2D{4O#}$bdeEYK4X;nA!T7 zPR6<>y~AcqJ($`)A^7)FN<{iXIl$U0BD9qYiGdw}bucIyjm{<(35|l@yr>5D)e0+EC zkUcg zwF0R)DIj`jC!rSnf!Zw|6|yaa@}^cCp1Vw=O0XWIq-|YOPP#*JFubg}lMk4iS8{Pr zcj6751{E*G;}?DLTBV!vRu3Z}mRI@tJ z7zO>FGhxf^@uqDB6v)m2SuZ*_|6A6@FK8w&1gFIY`dPJ7*lDT3Y1j1PsV(HVQpR9k4hk>^c3ISrF0}H9_+oQHDASe3)L5=@-%x5aO#_&X{@oMB3^i zne@HI=s3RP#lq)<{7?NcJ~2x3=E029)+Waz1vKQ>HiV+ZU_s-A;ksGprJVG5xa^Qg zU4HcU(DyyE1$=Kws)6wZLfsp8>!+p#w znKajBNU_4kOX|=|kNy&KH3U!r25OQ|TKXYj{*Hg88D(oRM>L2Zg4Jf45f*rUU-lS0 z8Y#(oBsQ&k=qJR-D*kSA$c<6p00g&JJg@QVw4SuoxpU)Tvv7}fn7#U*1SBQ63s2AW z^0~5B(T^@0^l$F@#HVL8%4IXyxFW3w3LAwaE+9PQJzRD?QLr$Q(0u3(^P57X&_Uid zR;pK4`$HG-qibE!k!|7C6vCB{hY&=J390snD@%y{&+7z2s3$@oo?l3OR&{Gaq!o)Y zhE4VXi;Rh?(}|A}Wr@WL{6%2OW!eHzi9wC>Weo;hii&Fr5&);nrVOoQMVc&N46<}VnAezOk$m!7hofLlRE^5QtZD8>O@56iMFLPl zZKxfaEKHDSC($nXz?wuEpu4Q$@0U#3Bg%Gf7-9t0ZNa{unH!J8xJtHoZVGKo)OZox z%(IYdSxjmS4IAMX zFm1A@lpLnVe6x}c6(hpR-60^F>x_v!jU_(;NmYUH5+y4K z`9w5R@1Oj2?}q7xdL=glP>RM&Pj#^ebLGQX%GJ)8_B@nFD z52jRFCc*i?^9r}!>ZjLu2A(Fy5H|8cm$b)dCcOc&ZhgUSJb$y&5-iTCpgG*m96@lW9u_&YS_ci)#YE!;D= zjL7-i+J92(;P5Bxl*hjqD(VB!ca@ZLxdji#3L4d4ptX;YH;x!G5YlN@GfpTfbotXX zqKBvF-5U7G=>aqV@7xnu)NZRx)yoOv5X=mma3gT#BwZ%iB(5SFU1m##ktv(zez$Zx zS8DLv00-MlRj`Qd-ip7S?viOhkGB2cB4ZrsRovg8DV!mX5RI#Dg=d)HSPCHH7W+b> zOH^o#?b!F0X594$agMYnaaD}a+X-M{#NTB8p;#bF`yjJtkbVoTekdaXoPwhF+9!`L z{r=gMda~6Vs?Z9fWJ%_sh`qgOQ_5j_*8D7B36ortPxj*0Vri}9<@XFKx84WDoIhD< zE$*+=Xj3zs&vX^yW~K#=yzF{*J6gkD7}>5?-?gOSd+kIp(yX%Rab|CWlXN&q*+l(+x$t}eN1`{Zr^Gwh%%7F zi4QQZ#UgF68fZZ#{G?z_a2f4eXvT5iGER;SH z$g{&P>>}4)kAo9<*mcQEr(WZ**wUY@=hyeq=tHmqcnUcnOJ@{>8?Z^(4W{x*H)@;{ z6*3HAtL&aj=M{pu*;AT1P-kd|QOLE>G}tGB`+dYvx7u&M+V6QzOg(4@9`pH+Vo!1 zUEOg`&lP*o-0nPtr(t-8Ti(f(wP8mUvL`D98FEZIXp2N#cMRCURM}SMt3I_|d-hx<92EOB1-_7rsu33~Y{lcN8LIp8R(T{c+O4toiHOC4qQKe7MQqZPk4$fZtFIrd`+85H zEQF-2N~2#t{vG*V1}m#>`bNBuzCTp|E%NnE#Favy`>0oFCcQ;}To@=_aqKs3C5 zy%oBCA&rQx*5bh20PLe_nX5=DryiunYbw-1}0{NY=) ze)yTc*YqEI-2ARdWcQpQ|@jCxH`iG9YlDgWudZd3Gy)h9s zc({L%PUIOv7{tCkZ)OnOj!+l}RXzyT0%=*)&$5iW6=gYy13m@?Da1=Uq)vmabCF(8e7g*_lO7Lw ze${|oK?@F0nlm+xwppwB$dbv~Gmg3T#7U2fOtnbTEj^6%=CvJe zLi<{Q0`p3pr!{V!cj~arjfF$=XYl2I;R0+Ms>p(*TQqaYwks7*j3v^^7|!4iUEd|f z5H{Q)dILiW-Rp9NRLjRL&6BfVa1b@xZn^yo$!0u)KvhahzwK-Ig~qEIN1XANTirrpnG&?upsA2xHtAwZ$}mq7 z|K#dMVcddVoh~}Ebhqea<^h##Gk&k=^`tol=yLwyYO=shMiuOb77K)I%DGcpR>g4dIy;qCs|dLDLModtTx7&|OJ)L>qq z>HG!BO(UY8i}@1wd)ASBE9x7BN*)Zv7 zW{qM3v78ptGG{u6QpklDl&NI?JGozd(E^7+4r`->Ph`6ddq!q^CfQ8p!cWH%Q;=W> zYmnlESKj6yyM^AqO+VHdSmmEmyMF2(xB@$2(_P;Ko!Z5f{tVkgbTEFlLN}%NhjnLH z@Wd`bF(>x(1~nhHs0`KUU_!qYAwo7DEX|un|rj;*1KrP&tWx48GVjIv z7Ff7rn0*{X(0OWkoo!HYNDifoJij!L^Tl7}a3<8K7WL9J8|~D({)dC&poF3Fjd5yForSDox!>!Qez&arAqFFC;5*4(ZX*sLV1fIB`S-ke zM!Jc-^_?#ze*B*b1~~)se=it}qvfPP7~luD7uqb&@V=Q*`x5GOhkFttv4Z*n@aJ8`gB_%6i37s?6x|^+bX^hXJ}mOY}t04 zy7jF(JdRqs0=U}k-*>#kIW_#ikGdI;Rx`GiWDVH6%=+zj2nSS8Si@_iZKHn`EBVMF zM1S$A!Gjasix~F74&}RuM9GJ~rb(W|c=?yz3x;~_VEwzB?kmK#{^h3s{&xL#(|_Eq z#q1zv!1zHs=MghOyimE!d;7nIhYcS zGBaIGW;`9f9o<3outY;)qp}kkg{=#-Q&kL#`j{Ow+AP?2>L*y!>47ICS#`+j7zrw< zI`PyV=y)|$bZ-}d&#N5gf4gbVR`Z28V|b)y>3BfxVP@!eEL_L8h8dl#TT-WI{2z!51(jg);jpjbsqBQW9O$sSlgu#24NoB*kV&MZ)S zW?T6;_dP`MoPz>3Q1`$4$%2EX;@~@+g1*D)zn?1m_LH%pqq5CEfB(H0bCQ+$M`U>^ zt?OugLpc$+R&+xFWLltfL0|$aKd%6xQj*e=tW?j-+|MBI3VW7l0+w0h-|m|HugD6R z#~$X81qW$b{lnIGQ0S^&p+=H~y>n0XIhM z8Z?a z30${teD1Y8^eeqlH*AkPxX7uuZ?H$~V^eNtu?OOh&z#3(UlI7>E`yt=4(>MiZhePd z$}ro(4UOA-QIJi@H4flY1yt%LGU$qOz}jlv-c(A-R7q<6kq5F|Ca;ks1&4fPwNJL) zWrkvxgCI!UW=htkwjHvSTg_@`NSak?WTn#`A!H3@>~@O(5ZClgpbPHMeIBy-9)+4r zYs5732iRZOYN+b?P78LOWnLRHJ(^Z#wInB_`l;mJE)ZGocCXwNA{3lfS`LDoxGpv` zR9F*ofPfh7wvx@$zJo@47uE9mnIj6Laz__Y%7q4HO!CI>=AC_;rZ=_QiMD2#*IGuo zE7bPw%Q56=io}IUi{)vUR|!x-ozKD~46}=~r{qmpTWhKnoe+xo`QpN1ia)`jk^Qh} z>0XaL`a%4p8P3tSUc&HmKb9s)J_5AyN-dVL1ckp_tL{z*S-gaci840GdBy_xw& zB~k>OyBz?B*?69bPKInpz#|Y31Hr{TCzxqNjZq>2+r5W0` z+~nf6w@_>|k)JHOH;$jU2o;o%PnkFb6>gFUjT(d_vv?!-mx!c%tY8Ug;==7BMSh}t zN9GLJVl`_$1E76Ea>BZ_44ysSg`jidSiaEvr|WovxoT5jvF1hK!*;#noCJ%DwaF+A zp20pPaK9#=HDVK&=nUDZL*64&-+_3GP&A9CQ;)+w90{-%;URg;r-X6b@Vq8D~ED6QVI3j2X8Z82QZQwatRuHS< zgn5%`{#1G88PJ_UfVniR+?;6ktk(9d_od4Vm!l2nxQrf-JtMZ08B)`;JlD-d4vLVU zIwc-*j!;mHJ$Zyn*L9_7;Qj68+Cvfftry|%v{_VYj4?0FJ8{Atf1)d<8a*l;-?M*h9|8k zx>RjkRp6yqErgZsATb#QP0eP)lbs~gH4m554?pEmH&9cZz@&61+&twAw?H@P2N7Xf zLiZnabp<9pdk!$t6Nh#d3X;ZDr5nhUoDu#9&&Z|}D}3IptQJ6pB*j>5B$P?Ejx3zq zNv9k{6~JX`@ZPB;T50AZXpxm91oHTG?)$`n7+`y9Lfua<8J2{a-Fll!k z5PcO*VBu0yTtxi7F#aMGI16GzTEz2L@jzo0Hz8NE{i85`!oFRJG9JhH)|^pNDhtld zi>9oJ-qElTbj?ZfqdSe$du*n2H6d7y*sGKMDCG3zKmsHu~=bpN~Fw9*ni zGwA#%xOOk{9gp;quWm0h6K9Y;-(JY9WK4CXvWyY>&CTk20%3N&=L5AIkBEvWSk)tF zkP=Hm+@Ii5J=8GBxBR}Y(vJe(!#3Yy?(lM)p#@Ekj?%A%{P;^ZwXpc)Z?R&(GjvX; zj*;yTT%q=Ai(^-Xv1gv(;*a0FQ#eTME^9D{eALbs{h8KM!sZu4sqG{PXZOHu=AQgg z_;7jY^L2Huat@p*aC-d4c9Ax{#O0dbyzS7`@*ZLqh($`j7jw$w3d&0P`8r*a*=mz~ zrOiMdb5=_hv=9}XOT{}|<;h`)CiooXh--}|<$#71TgP}3Y(c_R&$W<~#;bw(Y@`4q zLbh8&_5+bm;^YMDeYL-(XfF=4TF5UFprY&m04qiT($E(QHPd#GkpP>+tW%)GiC{6# zUMT6suZFpfjoh*>0yEZFnw$ZHc#|E9i3;Y?f~Y(rK{FO!y*86JUIcd(l^>bV(V2~r zd2x81=R|)(xxt$te>7n#H2pjW?P1sT($5={n){efbnko zKr)EhUN_O^F5fdAKfWA8l*Ov^u&AgRZSaj)uT>(OsPoJszpLxj>xHi<+Cau|6q6$_ zcn%G9*P0ddufPuvbC_Ki$&Qc-79sE)XvB4&9NuCfN$e6!^i!Z-8N+;gaBH}D%78>p zX;Y@)fvz@krF8+hdQ?45pFMguPTK z=$iMg%s_w1UsG=sL4-b~56mQBjzAckib&5JZ>W1Ji{lhW_Yx8)mwGUWZ0afhlBOvK zAy)u)nc*{{vx479DASkbQz2zpBx>zPWB8k=G8m*ksjkm1uu+b?FHj<1fJ=F+Gsjix zZxMYgC|_5}ahi3HJ_&WJQxlLki>!o5`oUaju|LF-AX`Q|cFwf^yW-+syKtwEVQkEv{spe95N1IW@YcT5ZpM_}_w!O3BWA zv+XEU5w(Nw=&bzm1)MuY@%YlVhuWjZ1*sU50y$~ zJwwGDQ$@WV)CWwE11yoCdEV^>FYn#Pb-K*vm!Nr*Zd-GGjvZ84D&|Em`Q1ioG})&Y zkvAVCRzH&h{s!wt$SMp$TSjZlfH4xTwYS6waJOpFJMBW&?*$vq4WunC7Q_6uNY@^q zyD$Tb868+%)B7F~qfa2z3Viz?*M^nG-6|gwY~Bz;6UNOM^z)|8QMmX&FfYBq2O(}g zFk{W@^Pt4zrF~Y88cq~% z&dKcgj8F0Gv5qSj`+y~QfE`~bAd1)oy(!gVVt~*PH5uKZ zuCG)mAugW@HGf?_uu>t0XvhGYDS1!VFimfHlBBfSP!-;qpqYM~>RRGcY|t|2@v^^! znf-?@W5I*emV*KqPNPygx$M#9Z9yk$F9K{>gYu2q-j_jfS^m}U@@KO%@}=LM`Qxce zr#-!k^SELcB-ERKMSKPse^%G_&|90h>h|0&D=or}p|~F_9Vw)zKRz70c^Sv(t{bMF z=&41Drv9{$|BE`oplVoF_Y;qC$)K~Y`uMK!`RrNWs!9S1Pk$V}eeh7+*K@6V;mN~~ zRU|P%k8`TkTw6D({PFTOzpqzauElCV*boU(v>h)931YKHao$@zUhJJ5En;ZTz!ECSXSqV58 zx==Sh7m28Y!x_pl0>=UnMfC><055MCVlR;2Gi7RuHzN8gYymrQMoMaoRxSR(JmhH; z+Ah7l@!D`%u!C#yeHx|FUyYe|H-6BM;V3^T<_mtuWpd@ITdZ zRJG)=jnTckHeH-ojNvWY`HQ}F{q!lQL)uhfp`hlRPwdSAz2U4l&cnuIi~(E?Fi{dU z=F$u3QD$?PG7IDktPC;(tgL{m&TF-2vitmJ?}qsxTa}I-uCC!Dw=RuO&)Z=lATm3S zND%bs9sGEE7Q|k1MSB)fwZHbRLe^yaww!(a7$~MhrJ{-=oc@@^2fKyL++-n<;S?zI zz)i(W7F@*^YfBxv^bWv#G=8?T>Webtjkg_g4U6eEOx7vX%jA&CT-BYbt3eya^MDJ4 z2c?5WeK+r%!`5m}+kUKz+tGar+hXty7jEe=1I z6B%d>+Zx-9km*jPz<4=g>l)nkb?MUWukhljWpZho_Wy|RoE5kJ-fU_$qp{Kuwd=^` zita@Pnbs6O+mhdiP-MpLM*(jhhYT8>Rg)Rk2f|oHOd%izQ|`BqD4sx3-?vgx)thf9 z_6SI!8j5O6Vp;+-Kh)-F?*nwa@}zTOShKp0C8PvND5N-J%8{<)L|D9vat!bx_!zekl$BuZ*%ZI7Z=sMe`Xli%LwJz=WV|%{TD1 z7Q1+QJe_g1{#_^YYJc2qXK!sk9+)cj$%&i8xm)PVi4J(jQRG(y>VOo#>};LQfg5kF zmX!>8qWr??jeut#t6=iP+i7K8Y6U}RkKw2O6STuKU6(c-+EJ_@2!N*PsG-aFOVS9u zB^hiCYX@z0kei=99tVJ?Q>A{y8UUF=O}wRK*34c!sTP9>R}=(Xh9e&AVYS#rBIcQq zOKum0!3o_&an0ltjFBYD1lj}vXRP}S=Z~S5yGG6}(gYfp3DhhQqk%{Yy4P;;J?$MJo2NjCxC+PE(VV6Uc<0mSm zmA}6Wm2YxDM>myt6kg#v6nZHx%Em$k%AUtdZFr4j-8MpNz-dTnmnYtuVRv`rv`={g zmrU%rw!Vp5wZT%7*)i9>q^1q&Lh@9pq*@Un?67#acsy>j&LJnouwYGi*&0b2c ziwBQnl*~PABrhwH3GbL(zeqAHm&S4)cuWnplJ_$OUcG@ z_VbQV)LT>EmL(XO;~Se{YfaOBLMap*Fmoe3C_?_R_<8M9OVA z_gBn4(ftrVpT(E$q!ft%BqyX|4N&NOCsUB`X>8&DK{6GwcC>fY<$TN%* zOR~-X zdY z>8u@$2lIeliF_hn>8rj(jZNZgT`>pIYFgt_d%hY1+6kFzCVqaD{8gcm>tp?NpkAZF zspbT+b{CRo%Hmm0YylYq;5)<;w^rW>V6iqS=O%!rMKIN@ub7KlT2S!- zb~QM(;~{~<0LIS@qZJ9i)vx8(h1AUlls~rk(%lh&be8VFDVK^Y_6MP1;Mv7Yz%L~@ zTGkK|&AS^4=@~V@A1szp67Dyg3y3#qf#i4dzTGDhNUy7{^FE- zS5rZp7BONnhqsd5?F+kP+$+P}<4}UhO;I1AxeZ%>%0VyjH{z_AT@g*Wxhdjt-B%OH zzg+M^V#gGbm-wn9lw9)O`2o0@w*tugn}UK)47sfIh3+G9T|MqbvBT^;QrN=Jh#^-u zB&4~q$!k>5Tq0zaD0JMy=L`#Y>v8THHQsv#<2|IpXd49xpOS%Jrg5JO$9X;&<omeanOal@w{F$L2rY& z$*ZhV>BsOF5P5^gS{PqAw^XHdzy5X$(8_WPbob!>5$^+nO7J7CG=>W48nCrRO&(SQ zj6KO4ObDzxl;{a5b?13}Bws#oLL~#gqrKIX<&woK!rAoTIAov8ORU`izH2o>|WEkZSzRj$=yun zNTX8$rnNlxy5=*t%-i19Hf@9`h^`a&YbwoQYHR!R@!%Zk^Yd!D9q4hF46m8!vPgd} zgtXMsZ8W4x{FxpsiiWOX7jk`mb(tB7RhZZ-mcGBRI$Yc>_OTZ(LBeR|urd_QtF#we zDHH96k;|cV}q)_rO+cvfTa0I6G4_=D)#l93yh8$X)1(m2E^1noDZ`UZ;iwodC5P* zp{$}P-Gd{g9?LrK3-8F*1qan(cls<<*=rv|;b7>sus@RY6prLb<}vR=oL@OYDPMBy zuv@3%d|gP3rq-OPM5Rf*gWe~ChUJf>>y60jX^#wt7VgD)v5jW9@=2fvCkn;O#x=^@ zQ%!C-McJFetCiBFAIwZdmsdip)|f;fMv9a7#B~$P)R@9$WkI0~o$U7*i)hyvWvfXw zrk1faIMhbUc7(Lcbacq>m|8Vg_m7jPhw~jXLggj1WT#AC6mY_YU01?!tHPpFqERRT zM7?7bh|{J)O$z} zIeSbH4A7FtM(a5ZyFhIuo_=&3%$2F*V@`y`hEtX1&CdJ-;?MTMjnb` z6U>_v9qb{Kc7ycsCPd?pk*n-gMf2&KH0Vpqh+X==+k0HFbxw=?O4Slf9axAzYw`Cy zV6m_Tsq#wm8wQD8{jhPhWY4 zeAoT?#a^?^ui${4*F2q#cq*GMmClf6CCBmX6$2%=(6+qp@$+Y8OFFPzRfmB}lU=E% zhN%{=(@Pd?=WN-PA>D^Gz#oe1xC9yvytYD`uaec*@F{Ibr;$_mh&Fxv;QGpTbl3Qg z&FoyzCUbHe{Id^y-ql(q`XfAbCEZUkfWAxbPYWW9IbShdU>~f$Ny0)O8e$46Ln6D% znw8hA=I(z<;?ednQ z6isl2Admp6$_&k!fbx6@fxuvP6=~FbgDJ^h}wr zZv6i4?JtRVPJ-644Gyc;U!Y~`^PNkjZAhkv@!h6 zLlzAxsvcH#;5M~Dbg?xt1evvV)^Uv)2#NiCN(!{WR|VET{5=@n(N1OIPluNHYQy@i zEW7+THJ9gKAv|bqyM0~gH0z8>*%B1MiQog762}{mEA1ec+(3h%P@{$_%RDdh(T5}m z5ep&NgG@um8dz7)r@$}nHMu&D-F#z1=R;cg;l7t}ydrP~02^CII1G=x(i%m@GxCJN zj>*v`7jh@d@#onK0mj4_xv-!YwpJq3#z169?5}haC7@--Ms)y z>)1(b$@%BKckEa2%$Kucbm}a7%@JRO$QIc>vgs`fomM4Zxfv(n3o~k=hnyXOU5s>{ z%u0WH{{Dyb(V}qBUhem8#RdD{GBN%)q2OQ0#s8|Uzm<^wby1x;AgLgKZ5lbW$fV2> z()g>mDW{WqL4biuf*~}@L#}DMg;~#AwZ&SGnLsVDg~IW}Z=<4sC7nX!{T8KyGnO}9 zuzSB`>we{97vwQ@fsjbI3kPX+xmtDbKFZwYcq0C|crBs=O208?INT|tKNN&3_+^LE zsZUO?zA-EZf%Q07iNz$l4hQ*bRh8|;*)H?_IJe%DDc$HJV8npOX-b^~1 z#PVDk;H>5hH1hzI(g^9b@@6f5jjU4^(BkHd%6^g8A+-(s-v?Y>flybHo85o=?qNG`$pg)ruUzkO(A{Uw= zN=@7+dvcl1vs)ko_auZ`HjxhWkmWR@tu+%>L<+r1y2NaxPgV2n45wx7TQXsU!&g(U z!(%t1bG@Qk)LbQnqSGuV0teka?)Tvbm6E~wcIPX`w39=A+0gSez^h6zueD{q>JC;c z*fcZ5t{FByFeLJS_$+1dWmpz0N1jFRnvlFr5Hpa%XLaDjop2N>LiEXJEl{p6aXg4$ zGz%h&5P}T^sRT*jm8Z;rSyPoF%<-81NWhd^U0M{W-;-t1KbeY^$(*!4(PW*iX6Z|B z%62DlT9h$p&@@p>c2$vEt9$q(G`Xf&3;p6W!Phd!=VxnbJ`#;(AyaKC;yuq=8x@Qx z%)F2vWbGTgY%BhI_UqLBXP9|v$O|THfk;2%Mu|Q}GC+OmSS)k_xXjEIM~nr#9}6@3 zFF8wcFxzaoJ_4$RYsBQXNu$ekb@0=5b@&sDr!N8w*^D4g)^u~QjH_~g$g_C=Fnie^ z5=_pmw`4!Svv}9RGjA7K6fE7^$re5g%z{{+NrK#OZbMQb?%s7nyrd!{Bi-7{`IfjY zin%=}UWi(!DsZ=wtyH08`?z_77nXFTylv)B8aqL_csMzS>4dz|CZ~(K>+&b5j!cWBT1HCP+k<#j zs!$|Vp>oM#SZVhPF$;Zaz1hO8BXX*p(kSceieUj?fF!k{O-7QlBbBWC9T5_DBT8kk zLF@hGNE-C&-#5{z2==3BiKEP?DrIz>r#YM0)_V|gUx25ZUp-?s1TlorbyhKpXi5LQ z5;4Dr4D%z5@Vypj{%j2aEk3*d?YMmN^@&!XXkMrd{&a#lyb~>S+UO*CvX+9}ktEzt z7&G7vGG{V!_#Ir(A&PY0a4avQb{*}>`5Qa1>4Cn-!I#H=unR!u>tlq&MgI}gBksvt-WUiNgKF;LFuPnj zqHfUQeph&@H@rouu*HXbrwiOH7il+g@18}e!cA>> zb5iClXXR5rpG-DJH^Co5&fxm!SBAux->_Em28|n{IVWfe2z?{ZdiUC8mFPHM4X2jH z1c!(ev1ACbIr8^8iu)xDGTy;%w@?csOr;5W#>TU;qxnBBR`?m{H*r?P+aIPK_m%$v8uNVC}JzEe~)kYH@&*G&{o z9n}^}rc-#jCvrpS>J_?!4KNhl&Q!&ph))~aGzeN%%EUIR5`-Ie1M^Goj%vZOZr|0c z0`fdD0goF2k;v#T1s7VS&7ZI9KW`Do4vdBOT}o5bYK3)0D&7$)4&;twyK|L3!>!|O zQo7q`*^~lhj5fn)Q(AE_4xM)x9F=$x_V(=DA!9!~SI!w*SRG(AETlv&BDNutVvRQ` zFWaICHN&*+N?zIA)=nA!R9T{^{BECiEb!qF%=F?N%xEBoeaQp!N+lcNxRO&u0&Wnm zp2;y=BrlOz6{?^wNW9-H9_MBz*XscuXE{SQ}U>3+f7`g_W1z$VZb+jrVnBm z-K#Xlr2NKG_Ggyc@0MG_N{F?$)6Sq&LeX=x753p5ZkKmlci+~=<#&>mj>is z2=2TfdX73LbnJxS#2h8*JbVuRL6kGvFARka4Xty@D+t9z8c4g*%|lNoPucD|UNAS{u*@XE z1ZSTs2IRHatX#TtFZ7Z+zQnX#C)29jc5Zw>0h+^m*?Gp1$!%&K zHDP?WT4Xt8{FZR%4rc`MVkh9devQLj6dX{M(Hs{wMfvAm6vXUD*r8vj`HCw#M)Ic1 zMOE@M1oC@$!-avE>7Ay+5|QE#FQlfn!H~r(bkX*;9CrKRceu`n`8!U{LWJPxr8?kpM7Z?^v2iI$V`JE>*`!kYAZi{k*<5~}a=gXt09 zu|{SIwQM}HO?$MCXaA_8Q?OBN+@8Ni`}Y_x%!WB({svJ8!GVC7|7S7&|5kOX+yAKQ zKCR<7t>%il8wK!z4c3Ywm=VHDKm3|}3t_-$R0TwATGpNQ+sDtX(Qo9g;cSb)d^@gz zpg~bWW^ZKhycXC@Jr{g{%8t&f2?nNSUhStlO{ZVFuCg7hN%?p_9|?RFQUTmCEsV#* zjz7t475mGe6)`;d%)6-(^ zytAJrmD8JKDeT1OiI}cq8k`G_1f9{w!CAs^3m4!jiZ zFHMR;a-GE3_(Z$YG`*b0#>wZSV2theW{8ynq7X(WnPCx6a@&0$$8ZAOg}6al9K5{B zg3$Qr0QN#dP-DO9l7o|H^b|*B`trX>x{&BgHxwaK+HEhlEr_U zMer+g0MLuCj>M>vE_nEHC8zJxXsqT#zyQkyH$`cu?=JkNZexuqC(~&;c7;Nu(Hmct zb-Qd9uZcyX{Q+vnXw^C1v`EK)UqN_yHk5A*3I5PDUKY)x-B+aGb174A29R%w<*Ro< z-LS-;9eepMfbnjI*n?2m!JS$`${65PVaO_7;#X}9dUKi*p?3tP_}LCS0=uoj;n(?r zh?}9$(1Qy&2Q&>Hjle3xLdrv8#oyoy!8 zC9HV&-5iUd>9en+2jl8@7w+T4$0fkBo3|X=2pNU^9J7RR+<-nC;ih~`$`R7$2@kUa zi+MPFIeC27W1TEPLpbVwb@V=TX5yoKt(i&OW*sb*-zJJ=`}=w_IQMjH$#3&ptUY>L z>$}f_Rg&;Yln3k{%CH8SN8;wJKHK%PZ7uK9(od2tZ;l;P?+{%#BCm@$7kRaJU%1Zi z|Do)iqjUS7bKhCK4%X9$TBd(Pfs=8Awkl;(3u z;#8Mnd(iM%U%~D;w(+(>m_48ljF|f==`W(3~>Qr=1~aW3LLd!@sOAg=o8m5g&ov|JlmnX)}BL1O@<5_{l=t{|8w} zMc>lNSkT7O@<;psf3ufa%9;)fB1m7$Dau5LTDkPlt>9MJBdDR!LGw&ulIbY>yJ%vi zroM&9R zKd05t&UkyiV0O8>73`24FrxK!1d(ycS_|?0K+nG9rcsLC2|;l!ij7N&OY)AAf$r_ z^E>nzpq8jdEE{jCGPb4btP@U5x0nOBkg|za;u!JE=FVd84PZ0$kB_W7P$d=>E&S-Z zi@WH=$)2GpFb8~>5M4-oOzE>1822=H;GbQ)=5*feLw8jRkyn^>y_ z|DL1+-D$KW7`WD`6amN9xoWe89oeS02p; z0Tu9Wc4oSt98FN{G;xkjg=1yQ=?~ z&!qp8c1&heDQKTDj4j-XZGI_9WU!=fu@EYmH!k{kVY($z@3BtW1lZ;fD2JfTZI_`w zC3=n)%hq*nsIy7p_82~XM#dGT0}Kq*FCNPG8kLz&&YpX`;SG<{ zM!vv^cnj_~YjN}6^B`Q(zsNc=MYEbN8llPZ9|@wBIJH9tfOmoiGNwgu15c5{Zxo43 z^=&}Z>lwKax0r4L_Px;utJ`+f#Fva&u|B)(&*leic+!~DVt z4&SF0-h47RgDu52#l~U}rQaHnz6mQnV44nGI|~yseF#J$t&m_r#6AVf`}3B&h?5x3 zK!Lxwb}N8z4hAF4uGQONguFfx_jo7gexB2lCr2su zCm40qhkjozdQes(7#3EGd8x#cK>~TiW3LRo6L(!b9%%82oG(?+jiX5+@H-+2|HaaEW zsMe~!QY!q`Qo^b)oX955WZv75sKI1T!Vt8VW@Bzclh6&!p6Nx^{+S0J{ToR9x=e*} z6z3q1f=RU-{OnSzyOY{E=DFMohT zltttg40RNA_n5nCrDk&ap-yvEZTMx+e2F9q{!>WG56vz2i6bThll=wrysOlZ=C$GR zV=`dFrHa>NPs<9DXXg883J_6P1uT=es;H>P`2EGRv z)ef6-=DalYQrYH2PzxnhS;emPuEC5W6(wa?<-n>e=nQQ|B!;q<>(?S&%Y7&gdEWnC z##2YnG5(bCsCV(z%FmRqf74J`DSjP1vL)np_9>7v1Gyh@oH2oEFcwY~MDgTy&^@A8 z(ly33#}qc_r7X)p`2WTBBFc#vFzxv*6rXSSI2U+sBpi+pf)K>rh|Bjr+xtjpux}@o z6;}2xHUg zS&p`82U6^@0Kp4j>QWfIT)T0b#c z7hkurc=?B2LF70f2QUr*z_KdEGSXt@|hPEDw;sxD4RZ?R?Kym zRW+M#T$=vv!-sn4_?g>!BQ5XKM!q~^`U8hp{5b0O__Hj@m$aPMLW7k2$GhX>@=MX}3{Wxc?7jewn zdcym9O=Hb-4DWKWkE3&Be*9!-eZ4e9%C(>H@x@~e^M3kE#I>?D=gcQOgK(3pcS_zG z=kOTcnx`tl(4R}vAS_zDf&iRf#EJ^#tkewJ#aV;{)VLbD#aY;Vzp5&3ScnM+@lXea zUi8nXcvF~|C>#9E?9jkzd_jVC%05sIYFGTP>ZA{owTS;PUkK zB}|Yo4Y~5L5e~#XH30=Bz*N!L8fF}8jqoxqajK!gW>XUrrey-Kyb2f~7a@*<79kaz z0VmDQCh^$e8Gj(xOLMF8b@&(-<)-Fg%zE$r*fX0A;g1Am3EHcmAZxpdCMHZ!<@P*Q^n!?)P6$Fta= zRNN?GM98|o^X*|4c4c9#fc}$jrd0L$6;>97hEA>)lnPx@H(}0`go;c3fVW8Ak?&qoSfn@l!8*E|MVDxRbwA3Tj_(K14k~d_h)U~ z(O_7FUmC@Tv=|6^po+NakuEFoa+qi6=g$IIGGka=h6ZvHGRv6NA^A|*JJio?!LR)y zOI4=sdEzV8_ye2(dPeLud}JLpsDXfXGT_*;vI9YuGR&DAhp8FXkZ%qKW4Z9q(hMN(FBfQ5oed;^(AHg(5pT1-R$`#2V}pIH5UE zmwbPSC3nl3fxxIgn-HpL@z+^sy}vd-}Qsa?erS(%i2-4TJ<=j!n0!Tzvn7&$F>@VOA7 z_!Lw$F~U_a>rc1|{PSS`09|?Sq}a6h=~Ma0x1E@ttqVkl21f(|LQVw}*am zpar9sIfO7tqUIng$-nXZxi<%M@gj#0389p~Y+g%2#d)`f5qpzQH5D!FV&44CJ=0n^ z_q+ijmpzkCi|k5Id9$%n++p49@+y3}i9=)hv`ZMQ=K)ONyhRM+<>Tn)v>+Lh$w-7) zJU)@S$g7y{hTf0`j<9L%35LY0@9V{WE0cr{rdxNVN#_8OO^a-o&|ZTn;OShtUE8lc z#WE-cBF)%^wv1#JMMN-hdD*{!5~WU~Yjxn4-Fz$4K{!c>aHl-V$R+|y>%?K*&=OBr z<6x+#>0~V|F>7Pwq}td--j8`ABlCPNMHfu$;+ytci^I$A5=@)xmquJhdw-P}vyfJC zw*KY$CKD_IM4e3=*n~dbq>)O5u=BW3ZFBO&2oz;dO^X5*Ekk?~Hf6i3#WBH&Sc_WL z!xy{Y!WW;u{dH_HjHSeyS9&ZY6Ey>E5$(|Mh%Q0;2E%KAR8-vbbbOg&iB2{vsQ37E znK;k_O$wj3{k3B@=PSdpb-9CtPMl||U0R~ib=75Nav|M={Yu@O48fblT=TGG&@bou zZsoh`=;6_MvJ+xIM-fHWV1C>}SaknW$Y0onn$YW_xOArg_|vjz`Mv(bT1G^$z17U8 zFzq239&PM-5i{uffiIo>9;P)kIIMx1hiChc!L9;aX0u*YQNtqFk((j!mB@gm}_Xq34-v3JK1FRI8%LEo@2Q)bKn6uCL|_j zg)}l4`JzY%k$Rzu`;9cyX!~Y%$@pxRp(cYVar&71>h5T6G`cbUTZIHxp$?DWf{{p| zzpzURf?vX2VcJZcxUzQ<1mEw)3^Y5-7#FC!(}`tF+=o_D7ktniqq_}e9X2;Ag@CFYvlvw?N-vS4w-P487uDxI^vF za@ND6t2-i1>M{*J4@m~2kuX5FNAX0$*}L_{E59W3hny0QdTg7F8pXxEN_B0fn$5bU zf}}&*uB-hnsIogaX5N;~>7U-{Qk|`QPKy3%rgGq$4hs861pyHqv z8QZA*rf6qRUsXY(k)Q@QE;OBkTYFR#1UaL-ukmK-f+*Pz9mo|W^hbGGBJcebk|w4o z&n7KTYWs#Y{;EEUEXZ-RZSz{Uaz;tRz|cmz?8~%@ryt7F z2Xu}tEK=o24u%}EqmFZYNif3S$dOJ*9%&gpoUVdLX%^}tf;fjA7yL367o9X!VH2HE zl&4XBc@;WXoxFyHAhDKY&(t{2@FzV>tHq2ei(#j|jB*`b9X=+lENbJiS;f7*d1mmi zvOGHamPTqmy};h|jKm?dVxY3hv?zkz_I=>$s;Z-$V+v$?Vu{S+!Bv9*Tpj!vX*|tt zbXp?ERj~66l^2BbTX!4gCLJiN!IO@HnO7!<%?%G2+vtNV^$oAaNu5$_tui79b02korTqmu zl?zGjV+(PP;~m(p9Bz!wjeyLfRY@lb zAR}@s2bP6-lw)!#A>}*mg#lvQ=;N18Iu%$BXWjQkx~;_pMJo3#2KVVO#?J(ot0A(d zv_zWibBFO10T{QF-GkE9%|!`+mbjREQ_`#cPimpUS?lq=OT=gP%)4=(!_0ekJ{<=( z`s5k0h$G~+_)dbSIMqYCRvOSL&QqDjZ@&_Adw3tx`=EL*_UwMeLobEsPuc5%BvU{) zGyJWfj$F^bb0eqL4~ChELSpXEYLCl$pfp-tdH(SRS4gk(V@q)%$>R3-^RBtl(~`I; zkjI=l&Lg{4*W|)C!ix!;y`rRZ9!KzrDKZ#QPpASOx4Vnk)_DzAT znnAK5RE$edx6t~D72sw)BSjk8F+fBZz@F@SLJ&9m!Cm867O+e=Y;S5piDo8uY9&v_ zmOX*hm(GZ147X1Y_s$p>r`LTRU>Yu(Z9S#ey*99n2#%$6bsZ6I@%?3p*h;&&Vp{ll zu6<6xI97Xh7ow=b1*W*{V)RES<=sjZY275qHVvTKL7hrFcR zs|~2g4yZs`4nbt+LLCr(bL*PmaRmXw0`Eb$-#_`P66`U?^%g`0rien<+&VvZ<2ZtP zolZkr`No-Q?gF?P=?AcPwE}wM)1FG^D@&`J_JF1740`*3dweQiKCP4ndjHI{a7vf8 z>8Jb(G(S7J)$Q>oeSvP8wJD4G;?sU)k$XuHy4N`4{JSc4T_AEGE^(6oRr~LO)GPk1bOT$t3WO3Z3GslPjO@19Hmq=YV~ppYiUd4{?|6 z4vQihk~~3e!`dB|?eF~Wyjjyc1@P&{gg}{xpp;|?-lcH;#$P7Gm_jf=OnFlnz!s4R z8=cfD8i^$oB1cB>IT}hi(aav1}{`y0k0@&WmYSwZ0CSzt%?4~-`~&) zUv}Q5yGTd8W;F~UtlenB-tuB=`Jw&>mDr#4_)8~MY;^s5Zg9CTPX~{nlKNR_Y*4h$ z4gKYX?v0*TYY?c66Y(?Go~#v;s+3%Svb|1`)nh9_IHeZNEo7%b{S>clp3S_cu&0%? zk@=o3c)-B7G>ox*Sp$>|?H)V(*SS4?o|um;SdU~|T`{DpjY#$hXtFf)fE5%)RPgz} zsY0Lz3{l8Ovs+B*#KnR>jAg%?RcQY#xYMVk4|=ZCpvVCkTEj;WL0sLUFf&P;Psu(h zQ8dNzH=Ih8@zQ<_VYmyNLrk<99_LxqS&AFiS_erZCJ*oW2vk@GF;lL#D^i+ET;FRy#n{#FE24+R7(f&o%8JM+E68PoBG zI_uReF_GqlZ58~ECCe$OQDf7xFpg=1@`I{V+x6wwY~lVc#X+9uXlcMoZUE~xs56d)3$XfbR>;ODyf3IkV_gJche?eTVj9+( zRgHjK#9>EDJ<_4PZ{1cuMfdrmud9(rVS+h3Vw{%-<@?NKI*Vgc6{sZ4osK=%N7OJh ztP`=u0}ND|TZxq^ckR)lkVtruBC0|SbVD@lUmgRs^m{0L1mcvI26Ge4km2xJ7q%-pW&!17&S-?p#P@M3eNqRr$L>d_DjaQlbf#1 z=3;7D;lnKNjGCJtT4gtGZ^j~+muvkjaKteOM~0NCb>rR4TrNY)H8@;}fwZ>e35g|D zXjeHwUSU|+Mnen9l~Sg^=P#bQo-Z5p0=uN*P>NYLn<(UZ*&CMshd0hA2UuW!_nXqCTR*-urN`o1PDplNqGCHqcC;Ff>qP- zLz!SVPs+4Qq*5vCZ(&w4P7kh{5Eou$F|au=DiN# zNTk&aHi*1H)iuB?tiBf+y-y>(PbR%jsJ&0By-zK@Pq2aE8S1gzt)GW;vwBc6~gmIpH)U5c(B#?L5SCnVp%3k{u)~$!tl*Wnn;o}`l3bPqBRotwH=4SHVT43@U zm2k!~(Ez;`Z@VWT`2IbD%WtzPlkKrRxD`|6$s5=ARkCb=qW%#{#8G4h=4o6O5TpM< zZ)uv18M!{_XiiBZaJ7Kal(X0S$KZ~r)NVIJ)%h1W!hJIX{{(3kzqw?H8IUyzBoVTr zN+3xNKhwyS+NM+zD>svsw#$u0WO_1Gz_(9Y$#VA5CW@jsE(t`XEvYsM$SB2pm;{PCVQN1%mw*hg?F*|n zLL$AsPAW8n2;Qi~k!k)ZmuZ0G4IZNhFB98+2Qa+u2Zqq^HG*!yYyO16cT?Hq$CILr zRd3Nc6TSVMq`}u~;!Qi6C)Br`25ZRv&zk1#_ue(j zTSrsnQsEf=E6|)_UqK=|ha@CxZ;kGcDZlLsBFhiPP43c1c3r$T-W4rG!^<3p89god zc+H1}l7>~DD)=O>F{pipg#!=**0;C1i)CHn12vd8d{~>xPQ@@q52)X`qI^B4puJs;JX9^^1D&(MB=)9vh>qQw%XF#WeUH zLYbmw9^nYAQR)@GN^ZL_YFrjOY4GAwSldJuVPzv}(BevBpP?gOjqn0cOFWaX;88DW z5WPO$6~~2yiCE=`(mvzfrTqhB>>hVYmS+{^Uw~ z2(|^R48{G5^J`uc?Uo_7JC}0@@m3t~^UvQfQO@_ryV5;mp6SaiF?KsSs_WuNPt{pn z&){kiigdp(sI+hihQ7$)T;9{+Ui8g5USw?JD2EcV;Sq9Ek$EjvgNXQaL2Kp|C?~d~ za(;}e<2g3w9D#GO^y=th^QPGIB?FDJJTBM}{`$cHryw$V#nk z#e?m(6AJUm_iOI*a;#5{0?A2#JOXrZ;x+e1)V}FUXLN6WgF*mZiynRsFrhrd3W90? zMjM*ufpzs2sxHFW&fHvc$Eye^)exn$hklqNAC)d4$)(JrJyE3R>PRata-Uchhwvnh0 zEnxv_BFRP018PbOU$m-S$Mjov&Rr5w-FFLfPq@-6!9P#S(Hx#rQx`NS@kj~^febNt zD6sG?hLqMY0gM-4I70zkpii)H{JUfcg0*2V2D@b)6YZIz7*v znXIK5gJi#?uFa`5ym^9Yu`N^SW(mx|Jz8*1+vwk~R zNJW%m(GWhnn|SAmL5EAI-4)__PP)6uBTl$Dpp=i37j_QZD8~&UhvP5Ec`Qa&-NH9o zWZWNdsg0MDL+aUYb99GZ__kf(Np#;%C%`~>{T^7T=I3}c3v3pKEf(_Rg&^^X@Eree z5!;qex?7wRnDIrR@`$v!C1`wZmR`go4Y}CRDCUJ?{l+eus%2*LnAE(XZ5A@7!6~)8 zs&C(oO=7aHU;j9-UoR9q<`Qd><{Am$_9f6DvY#i()%mJ3JfMnpE53rh_|OH|GdQqY zt1=oBDVob>y2~){88rwL7MMf&bDVN{_MV6nlhSu7_C_uBge~p-t<(*xqytD%1DJ$6 z@A>3(`U>4H@rhog;B!_Q!3H_tHCh>Wp>(t*iGa>JyH1K-2H1#3NK03qjP?pJz!esU zizXdciZS-)?WZo`?5{M8cPDE_9g8A<8P=@(#wnWhnpH3i#hXoVhC2Sd)wUCs^1?(_fQ#_jkrIXUyv>Hs7c586y3k zFOr|1#)wJ00S$mgj<`^=cDxTPd)i;v`|%p$j}7&S5iS^o$`1CtdeOM6OfrvXmaUkh ztlm6>1^Zz8dGvLvQ+y0SS|+b}D&xmlr)gP=KVb$$-vA;HexZIYX-rZR#Z*>oppCf$ znv-=YOrnRQ2co{iVOnp{ho_u2<2ac)Qs4Tq#f1EA0;qsr2m`#YMcq4zsk|4rfkwvr zZ;ggAEPs4=5?@|SZkIpYymk&m+MAIsC3CoGjx;w-4sX(4uHn(&kiWvZgu&QGo2bcc ztu*P*f9^brFj>^5*-a#2gV2X@)**I0!ZBuoAgm8;;90#NiHt);xDR;Ad%PaKzQxwp z(V79P5}B+B+!`4$YNYedG}xz>isuci(t(vuV96(C(=n98JU7$e4ERw^xdM-IS2YD{ z>I0|syFbV!P`7^9l$4RXEi?P29sv-H948ujp&Pt$kfSrVqa`VWny{=J&~1e4px=9% z|@S1+qhJ41Mpc6)LlZK2H) ztEA^1*sUP?jMYRgFjR!3^Ym5M$%oHL=El`?PEHR1*FXfD(P7{iWCPjc0$Q?MY#o(h z5Pp3gdV1Fw+_VuUl){*0IaFErpHk%$SKX#_Pu-HNyYMpGu0CpMuJ??1uTm$pWs2e@ zirZvkjLzKD_G*geKNwj8LrfYK%Aza6FYlj(>pml#AswCCMq*&dvKuDl7XcGiiw z^H}4TiNcuVbBV)G2sRGF4YKH~FoIgFZVi*j8;zy~Qd5dA*`Yb7Sn1K*n;i5_$H~=- z`u<}49#E2LKFf%flA%M|neTL_biTi+z}0}{2LsU&NvJ0iBbz`zqq7++p*|ECjBK>% z226c=pdMBVA=km4_?nai^Sbjnmo&U8G}enJI;@5K5(#kd1inG`5djgc5~3CsSlmRs z$yPw$Wg_T;$A;kvI3d9u#AYe>K=H%i@5_3p$=vYSk0rf{qUhY%S-E$FOLduKk*V7A z9duG@DO3(xkH*Jaqrk&?z{XJd%y1p~j>HcOK+?|$Hf1$RDpP34Pllev=5WZ*69&x@ zT*$sN(Ytyx^U?Y?32E~Q+dNSfc<-R03l9+%bd+My`n07I6ew(2);T*wO&A+t_IQ>! zBpdGBKMo(_slGw$aM9i%$iJglh)^-@AiX>Q(=PE79M53A3RmRjMS1MOFfhES4YLDr z5UG(0;X_>+I>MXZd6{ZPK;PUeNJm?F-v1$$Cijptef$wAUV!~;^Pc~Rgnu6l@c(7r zqr79Yq4Xn~wpV10ULe+9U=RuMizYEMtEUq&6Hq&aB`Zu5YLEy*)f$oHR^Y79GRMPt z{w)xS3yZi92rexkRykizKvL)O_3H~haFA`qZh>kqPf*_ThWk15=6$;DWZmcEVdDmX z#*i?aO(%&ySeV{Jnk(4|Ngg3)g*eez>}OQ-Fj@6@Xg=e^ zf?pM5WV6-Eqtu20+MTns3&~7u+0OvF5@zg;dHeP)bM*FGTL;d7FE9qo<^<=-;x&clg~AW?)&i^%XDay z!Fe;M<%Wv1r>f9fxO_f&1U(lP9%EPS56(u2Wmo}hZht9F&w89%cszv z?%#6T?C;b$kedy+csUi_-LcN_7ivPYs|fST8g?eTwB5Qb%X!0@tH7>``Y={7r{pa= zr^I|Md)-0FN|Jk-rm?dkmm(GQ+eTG>24*=-!?RVc@FNjPNlJPJI>p*N``Y{!yn4&$ zaSVK&*zYeFbV=G6cNJyq#5-b zZ;<$Xdj1;ARfs89LKY{;1P*>8G&X@JUol;FehF2x8>amAK2{ZJ$F(cQf-f&(EflJ0 z_3Y}FNAfT@feLUsM3ez-d{@lv4EHU({$b8r@7Asufae~4gs-71%nX?A69A2j?T3fh z2Td#N#Jir&bKh`?-T~kxB#$tea}o{BA6t68mkcBk)5;*p!9H(cBSEnf+~kglI7&~B zA)j8Tj2xPeP;#Ad8O5#o4Wdw182<45mVwLb0^XS&{!75ZE5b+~u2XTUSg6|>xcwZ# zV_m)@U4vwwAgFH)$PY}admDKokD#4CifxkA19-v@ z;e;7-e}jQ*4O4!(g3i1Eoig&_otjaGo;)X=CkN7BZ#ONx0G@$23#0pr&?Rzn zq2>1njL^)U)q5x?X`lXO#K6h99PXuUK4d)_5*dAkQW;H+Uocv<;I%c(!2KhMl}YCeCqbjg}r0J z#uH7~307y;7#mjchZxajjTylf^tj;2GSYYrmhaaM?X=nhE?R(H)*JKM=9t-};$DV} zP{m-jr$~wc{5ekBAl1RXm7<_>mRL&>sUenNPtY?@>&IG7$HZ5NtX_u2)BBm%)_ z&=tm*-YZF3V|gk|a;q$tDsWx>@NK})H@b ze|m|zVAzQvgn>vUYfRkAY*%etZ*)#$F^jQa^&uZ22#K^`2iFq#&6$wTtM{rvi3z0sS%L`JPRoEpk8=*@s((Q-#>(U}g8AoI|WDX*u#ih>FMwqb~ z$x2@|Mz}o-3SSNN!7hqVn16ut*Cjab#7o!h}@(^nw44AmombrD~Libl(Q zgKrU8`~fWNhMXJnd+hh;hi@P~Z{ZDEvAD|GfEY3EE{3m>y$@9wYZEfrLD~L2YJDJKO|I92PiB<_lvmw_R?4Moj?5v0OCA>WcR1*|9k4a7ViKAt!$MyuspvkQwgV ztv+~y3>Jq70TiFDTe%F@H7LU!PBet*^J45Ji8mL?=1|^R7MF_iA-u}nFY8}7vbQu{ zGjUv!KCRn%pi_G^+p@)B?LjffAOCQLc@5iCH26shJ3l1E|IfsOf9LG~M^gANM3#lk zf*Krm3Y*=&Qy!AWHe7BZ5uai^7sQw|YameG9)6J$5YJY7OW$Zyfdv>~PZ(@vV#ER4AQeAIs6EMEpu6S@9C~NEu2KSC-Yjvzs$b0wgk6Rx18qGuV zqn1uH*9g3do=3H=wY#;)-?4Fv`-@F?Vv=`T3aGZ^EoZmcB>y}PDhVgEHU?hq-$~#) zYhQ;@f_7?H%1S>f=TwtcEwuLX*2&zZF6DgBT(gdSI~OnEQR41>Iit!m^-cBTc@=N0 zMI>efrov4Gz=6wcqyh{A&bgS+>IYyS(@(^4;n;MW9#UVWyj8tcWi*X;tAI@0Zs(J` zB5F}vbOn4bMukcbo6t4ayw~)eJ>!s$D|-+H@@_r7?0I+1aG_`lObaNJgLP{?&ZDMk z%zJX)B!i`9S3H5t$@D8Y@Zg1xor(h69mfwVlWD+m_5of}fh#ynIk#=j}2Awv!&4{7Ll% z=&LE^y~Vud%=fC#(r%u)ZMOcOnj1pyw`hZNH6ymhfZRd%QJh9og%|yZ!@n&+W(!!0 z7xeQXF%^$%Ka!pgFEmAazu$q|dvo&4zd0_D2$|2^Be@_kjQtFYBy)NtGFDaJ{1+eQ zdG#`8dGJ43i51yoR0X$6r|?U*hQaSi^93>o&G5L&enFX>TE<7&yVXlUQ(L>HRE`@f zM?f3#Jl--=R4)l!mhxa4=A1n7_ zc_Y?}R(89Sbi5!vRi(o&usQlcIhVF2rlOZkA$mq+6(g7>Qdso7u}qm$;7GfqGaWba zkb!jvo@Tdu`Rhl>v-5dL3l5`VxrLh}JyORGzy2Y;#v(cQkNG()6Z{;O{}n0xU!(Sa zlEMl9MhgENmlc~EsR$c4g*tbOBs6o6%6~Tn>q+(g62Rj+UHG94;*C=-t;0M?rJ3aM zcwWr+17_ZgBTbwsXOlw&Sk~AXO}=^@jx*D8e0sdV=mJu(PlYtVL`6s`D-4kg$1zso z1a;IA$2rR?$&IB)=nw~}1Uq^x+{?g&rN-I?TWqOXo5qqWmCC~xLG z#nC$K{e(alSUw2`)Y^@e|3vU>+BXvmx{Ng*nLG7RZAr^Fn--NEqV=yMRF@q$2}>6Z z&%TP_P`}S3cONj^8gC?D#}jkO#yd1Gy_7*BarE(d^%ewt^PgyfqOi1}gtxhu|CxB^ z$s)-jzX}tKYYEf_4?K*Z%&A9TpHD-k$ftbH5=56OWASpzr-K_a=;+skE^WM`790sy zuM5(35>Hj5^5~|7`tIbqP?hX~mouI05F48sFgowsG-9HuaKY+O& zzD+zpKW57|WD9nS21R1i$sM(W9l#Q7ow@^nMK7+I;|*?8QJz9RFXzQqevwmCZfhQx z&CqG9wBs!9!fw_p9I91f)JL0tP*^~GY#gq+mDrw}3dLp1E@J_a)*UA5(vX48B1R~m zHfjneGg#miZ*USi1?Ffd(Cw=)APw~_Hp6r`*UbCmqg?~uV|m;ofm4GRp%Y_KeFxg1 zMwVzQ4fYYHIEpZdnRAA?QUrci?S*-|!|5m;*Vl4jhF!R4qap;iRz7RtZouOSZ7)(DYBv+U)YwBm2t^kWwk+}&2~pVsTf zXMOE)uqklm`+&sU5uu5eHsDDFzNHBA2JJBwGkyGHm7m@>R2Kj2O{_l!>%U@!|FO#d zpPear#s*OoX{2Xhy{^j=6A{nK6w>ckEp{m4@4O*vQ}bLldLjipgiVr+F!j|-jRuRw zN1J`VqWw@2^CFzKXSJtQ!V!A`uZ9lGk4IE5bs>wG_o+0c@AGzu28m)1CQ&iSxvv&my+skH#+ySppC}{P`v_#L^W45mR zmdgie@;@Rr3zlcDJ$fy()_V10=`)T_%l2k!sU3UlnoZlR7 zxZ=#VhZ=OC$s2vigEDC?%zD=Md-Q&o1U>vyAyIM3p2{bAPaw~xW*2Z1FPoEs@Dj2wEAx; zx8<3`YUFSyiTX1Ro)#Z>5%1*vDH{$My=witG80Q1%^+z4K;*li6^)$9!Z=B%94fMD+s+jID?G^O zQns3zhNvZ%rtY>wWyoNGbM_p72~)>%`)pqc?@K#n(b)VAe{~P1`f;+Ar04r}r0TQv z6kK*6G-*<+z8P566?KApKaeUmF8b;h4r7lzi4IssS4+AWGF9q24d?q&rpkk9>!rTb zf(fteFj^K?%ffj05L{o?Zw1WCG@Y)&9 z7Uf`6&@2BAIwe(Tii}1c)dN6jwI^qWxgIcIqo*m>#rKA)v3N_|)V^NYB_y*ktjdH7 zgKdXUz(=P5HY=H1$M4nZ9PD0vkBIFW;NFz1Eb2&iOLYuO*74V*7v{48{@pQ!m?(Rw zEwojPBQZXcAlfDNOt@QObZW@nfh|TLWm5}CCvp$tli;NcroQX8=dWK1T{mpzd8jj` zD`9vL|E(h_8{uas>9!AH!Dm8fSREyah!6~-SDYoHon>-pQR3OgEG`uGw*Q@I%$E=1 z+ml*PHzk{UWl!Xo*!RHmyzY%)PJdBocY`yDP6t-X6;ssdop4LrmNsY3D*<9c~1MExZnHVpmYCg-2cDRxk?uQmH@aBYjh_BaG3J;&H@3v`J@DZ3h9IOaO^DL z3;Bp%Sk|N_^QWqrJEGUWioF5A5z54_p1;TzIXg0*B8o}sI~g5Ley+H(Jxsn{-%fM^ zl5ZtZOl)OG$gWH75~4v=l8W*TL17n5$}M4+F6A*S(7BfL3W^hE5}2}!?;`OHUj^)U zlAuajTDMT1T&)(dMMu-8xMf|To-wK|lid{CVQ4d|tsoa#v_>ddwMyDr>pruWnXS7K z9k|&lpw^`SBkBc>)e^@ms+P_@d6mX}Oxzq=&>;r)O9hc9>OLq2raop%AT*&grnd0M z3!o?9Y1chA1iJS(Sky@{s>iOVX{ei`Bh&LmwgHbcBByHaz51P^5uVDn#d?~e^Oa?D z4Pon#)q4T+)x=OqyLaTIWT ztl2yZ&NqUl@M9>|CL(!U^B5=t|TXrfs6~TbF51kVpkj zjJz{UVqeI$6^X@fL>&Z(cvCzgk8?cu~mXc`aB;DsnX_$x8jT zV5z}_lG@Ak!~>-GcTH!#Y7uW2X1IJ*TY_cT9jvy6ADAPW*W8_v1rk#ejJ(> zk<21_Dd|biN8S!z!*Ib`nF&H3zmjmFU0KPZSe>Cz%ht(4+{O-$7&#M-3;`*2xjVH7 z!7n{2ybauOQDpHlW0!VkspXrwAnTeTOqFx@+Y8ZSW@jm;;D3Nx6O(z%E=dB9a`rnj zIAc`1gCiWG73(DT2I36-i#`_9nAQvWc0NvjhpZ0WDt1wJi$}8u0XL}x5R5eijWN)L zj*(WbfpiNVWlmclfQ9!Y8kwWuOpUD5AjTs?w7FukV{*vij^lu#)^g^jlb%f2qm ziuof^;;??4of_U%^1N5sjS8*i-yI9^b-EXfgvBCQcFw;%)4Le;qzg%JBJ(I@hV4ZSDG_aegss0MEgWJCRE=3qJ8W4 z$xX526u7yZ8uWm)>!FFRl1IK4TB{VsAdUcI`^;lSaxxOlJoIH7BjY0g(&@LS+b)6x zdW)Hzh8R9`2_Bw6`~Jr*b}`)~6!%Z5O8mcp#Qu+9{s$79xMPFB4>!^SIZ|`61l0Ue z@ntFuDS8CQoSqm97YPntMsMXhTXNLi&%Dxcd~N#ZbI*^6d=T(3NK|sF5JU8-l9dS{7W71K6iJZ8820l6zb&r}MnTxiK z-mTvW$0nWj2FjlwOy0&(+eFT1jhCovYASCvFE{u|jXy!ZqtRBWZ6vpG3%IX#z6q<2 zlj9uHCg<6z{;=aG{BWMB%48$MsiO4TMy}#cLHZB;F6d3MN8oifj=O13U(WK8kxJMc zBl;cZpGQi3?`gVuSo$m8iDmAev3CqjtY;(NL$X z-u(+%5`&4#!qxW)sT>1pk%>!4djPu9qBTqtN|uJ{SFlOMaF&(8Th$SkP}I6ctbpoq zF}bJvJ+u4cltbqZ>qBuGkF%GgNMOUcoZ|fB1&|sG<-15c5J`sU1@XKNz6h?Kc#S9E z0;S;~PaMVwM3uO`KZ8i}p}=7$i#Za{qf<1Vylb|@q4XI9~=%)e$= z|I4cUPj*!U+*4_3iT9){&8;CQuoplOD9kb#To6yd7fu1lz!(`iLazyG4CGgQTB?+q zR>hFDb6rN&YIzZmwq-b~(f_L+}xqSC`+t0|%lrbWy`wF(_ z?dR*RlWeaxT3+w>Lvn)j0Ta)}UE_HzyeZD2wprPuPAw72LUr;f3f`JyW}WWQ8H-ng z09rd;ACb>z+JFpbos$v-o$I5gAH%di1u3*i-U&J3ZVkSzld}BYDUmcO#}ENK)SoDB z*bjz{OEc7)6kvl#b<(q|DiVWN_pA7bV*n+s4T-58N7@{{+?|pl9g^Y)6-JIuzBPLm z#*SG`E0Pb{06V>`UfR(9#DLjc>IILL?M zmqvj7-+1WvWVqorN4SszP2`o10ei?g5BM1FcW zH*D{sy!BLg7wlJ%&1W~mSpbWE%CQ|iLCRMGOE}zDlEJ;H;k>%Zqw3!Y-uo9;EMHxQ zmoOIbk`DDOd#MLn%j@Lh3YMM)T;`Yd0rHHfwBL)m-s$BBx(zOXXv%h;%oulC+jv*^ zu`W2i2~-WNwiCEs0&TY84e$MRbp(b~7TYU1_YtiHO#wZycFsIADm9$6vW?9H+A|TV zi9=u+)+6i47Mu9GD@k|eyQry$P$*CMio5d=gTcddIUTgIq9dSfHiVx2sI6z%oM%&!;S1~suW>-x8&zHz7w=Cz4s@z6hMyyv2hpk!Bt=B+mFoME9 z>OzHWEUA~*XA!|+P{*BlE=4_MHRP3M)=Z0Q`_^(c(xVH!x*Yxs2G%$$wi;^@a3ft# zoDBx50Bdbo8*OzetSZX}@=j~D(xgo**~2twg0e#fq&aMu?W(x^b%Fr%^50>aV8({f z@ZKlzR}S9!>~Q0$a928Ga`M8&nG)g1=VncV30N_q1kB&Jw6h#(`|@4 z$k6JC+kXeVTL>eP>CU?Q^C*kLn(60Gc7fM~F} z0>H_O)8NCa!*q@@)6V-V2NZ3D`}}}_IXD?{b))iRW5pqHZKz$_>jhPh(M#7LxCHEe}1^#86bw#CVGR z@z>m})ODOf0$-A|#bYP3Weo-y9)4lDj&N@p(*kkV8SwrIMV}F`0PC|dusjaBqb{lT z^@FJ^dwvc?$*BH7qU^D4oz!+odkTId48Tt0-I8HHpF!_<@G5}=_s_PxV|ZqJ92r~f z=_#+N;qC23F^j*{>9M|$a@EK(Dp6jcFsR|-Z{en#Xw*8lvy2~0cPLh|V+7Z? z%PW+$lI!aTq3O`dA3J^l)3SnL=wY2hz>$5rPhEN!bw*XvX3T}rxLZ|0*K#(symt?> zAF15HggfYbzlV(o^S1Fva0(0joHOY$&nMz~c3c3Q+oe$<^Qtrb2E8NDHQv-YW__8z zc_W`!+9llaY*_tF<*V_Qo9TOa(iNe|$sm8d7ks7k;fm5#_toC>~&Uxm#MZ zaa5Ryx<8m8@6&%ySLW5Gy?{Y=oIoGpb1Jieo$bP0apLn!Q#d2eh|Ph0Q&(NOPZ%9K)f8|~skwk**F_vaty-}@Hin!_MJ zBw5Fp9Eh-OcrL58rPxY7GxgTm&ox74aszq~Ly;?AXn6iJ)#73*F7MvyWZm6psAwu~ zgTQbWbybt{e(@%Cv0$&5K(POvdK`WWlDe|Zx+8aFS&-4kB8`5+iBh-_9F+9@@o;E3}U=-{O^ieQm$xuwxK$yTdi*+f3 z4DgV|;-7Rp>wv~g75vD62YIhQj2iXEAXE*>?0?i3sf3I2#DRLau0WR;3k7*DPu#d0 zLF!L3_|;MWj%K-oI$`KSk`GGf2=*rx#L+a1yZQsB^b_$gVO#aq(zjQis2;Vm?pwUJ zQP6HV5edVMbDYI{{OOm{*X6vXPZ>NAMV0+UL!c!O4Z}RP^w?@yC(79{-DB5*E=Ehu zW-O_R33{WaMH^K??WLs4$ZAQFwO7eLhcrv8Qt^lSQNzqk`_`p+75MHvd$bXi_!INE z3k3m3$#`MOn-kD^r%|L^_crd0lxwy=J|eO26=j!AJ_pb@oybNhvOqeifl^bA2Ay}$ z=Dy`q4QgJwyj6uB-Q&aL#~%UJ_b{OE+;92qMd^r%onm;OD*aP5_W=DPe;{dwPTx8z z4Vdv(@E)!jj!EP)S9994a94eHLxloRAIFWkvF}RzSmU=6n>eM}0Fl+70c{&i5;bM!WC3+sTn)1B8|&DYX}jIdV%zHT3qdL)tEM1UTO3?9T!JK8&nt8 z5ru>IqP9hozVM2k*#qCO_tqcw!Mh3LA7umIi5~vd^7knc*HTw8tJP7iHny=uixDjY zx@Cv=M01J0OfR&z&Z<-`P36gFyrKxRo!hBWIN_&0e*wNnRr;2RYA3gPUQ_?$00 zXP@TjqZ^yqC}%GL(AiHU6R6Fb0aTg7i_`;)dP06oOL6#QW?xA5b?<6Q^7$ebyBYsvMm@Nokz-Mj5&$s^gTNVWwThgalI++u1An4WC6f}W(-Aa~k=4z#U^#d6@^MhlW{3+53^r%f6| zR-`$rOA;Pci?*2Y4Le&>?=?^F{kFMwV;-b;Sb~!Uvy3>8p509A-Vi|7h1~N&9ZMnX zP60T-u=R%o)Kxr}CQAmXEa>X%J8NcfIMWMhU;90s2d*d)w`#lhcslm%Xb`t_AHiU@ zO4sO}e`|s%y}8uEb*M=039tDwzYfeAS(rbkB>9!6td;8sL)et8i)rDh`a&1 z_nLJa+)*K~qg~p-?0QBPkUIOjqG4AJohVs!;oHM;9mF4lxd(&1ySRj5=+I#ijFLTv ze+ww0GGkVL!Gn2Q8qupB5`Ve622}P7YX1#($>()t8HdO{mz~sp)VA^=w3}!bIBU?5B|nbhL{JcEs6MW&Z66YQe&8}=ySGUEHyOgmtCnZ7 z+%l?`9QdAc?^)X5nR@PvMZq)7Y`)0_KM!LLCW_uUU|gkQu8q(Vl)5;ISXZIpwK3sZ z*{i@X{Z`a@u4_*4rlTZ3u$)z(PEcI%rU$*p)Z8J;u1D=W7~FQIBip%Vt}DXbt1!UDZ{p`zxW<68Mr zb0hI3JXTTJ??hRL#V^cm^)+{sd|*Z%;=1npKa=7%flI*yBHuw8U$GLmWFC(M6l0bZ z2b(PUGYTXbOT%(<+!ea_n^yziO2h;G< zQNAe3qh-fqveIt4oUQ7V)z}AhYDI6{kIlb`$0mw9ke;$f)92Tg*r1fXlExyTvSRte z$M0vr(gpb=fp(9@Bxs1HJ<&t8!H00s#?fY)`xu7z9!%|1NH*e|A~CHI3G=~(+7KP0 zQNVPe4y6n8^KSL2s^yoe<@M)oqG@hfQh_%{A2c?7a230OZ43>zElYKzNv8hv^{c@#W5XIrA{XnATf=yRTH+UGX)}M1WK+OZh4p0^PSi*pvhj|&-o8fFR=1k8Trf&^;g^%s z#G4tNEme-CVz4@TNd3KqfeF6}5SzcpQvA)Uy^JvbVle_0b!uYiN2rA4_N4SQT2Ec| zi87#jl;nX2=E<9SFGh7BeTKUuv-k=fE;?23m}jUx47>Lvjh0LGt~m^g9vCG2Nxl~Xb*mL3H#TECB12L=Fhr0qBZ#bCG(?pc2l1+2aoyRTPg;$*zEkF z^}342o9eeIJz6)^nXE<>Wja6!^j?7 zRi;;mpm$)X*Th{v{J7EO0*?6*@}g``HdUtEJoyPS`U={)g8l3t^h`{zc}#D%?5}*n zz6|PSC4fbDv{_J;6l$01Uv9;7ZjFcJs8wrX8k6<&FN+*P9GIRVxVjbz}W}D zrkPpTP&cmOvEVi;pnsT{tG;41QF8kzT)wPCql|Ju`~_wI5D(T?>qel$CnE96h#IP| z;qeN#IPl=Zd&{hQq}cF?ze$RgMtqQDjK)*;BM39`3mUvo%IqU$3>7yAy|{yTYok8KB4@1E>SI0ll-#& z5CM)}G6%Md7Ip)MCLg2l#&x0dc2hLzbJM9C&GE$c+bZuii669yC$S@UM_28k{_wos zoFB>zI?q9a8JeR)icu8}`ta>Pz8jkm^??|_aHHK-v1EM<8o#iH(}mg&53*$sp=ZM} z9DF-{_^ydD+B7WbERXHRpJjh`b1^IeoHL(S{8KIK%rZv(fyhBT{F$`4#IK|7Q{pHv zY6cZePxWg5nF7T5m5BRFj>8T`W|p?1yCq7G8wZ!YVvfzIO2n4{iEBjx?OJUH=A?&w zVy)Sd^%X z?lvH^DpKcAZAnF&m7=VQEfUd-9$FZig>b~HT9`H}WD7FX1Zy%j3uVjXY^ik1Rpx&TkM-)Rg9O8%&&*7n73G`eH?5>{Y9G zF6pX0awW5s`vbu||J16yV&`b7k{^h7-yuJh(Xcc<^O}!57Zw=it13-$fQkJm5lR5Y zOJB|1?@8N||FZ@!UjJUvU|>i!SiTLZcfMu87B-Xk+K;3Y}`O8g*{!=cI75 zrLqrFTSLR%H7!b~`=mC7hC0x>7_AGx)lgxT@K+DlD%@V{Cl6LH@7t$4N7lJ5Jg1&2 z;uJBv-gNe9lD%=7SQO1T)TvBd6Pa0wsZ+4B(iWj7712#K&`o#lb6{~aowb4*Bb$G{ zHsdjryJ1(k&i$g5Ox21ywoqRXs)^2OW|^{NubF>dDBVzPR_zMoYPL2MqueOnHc+2d z?iYCYLoPL$IzPTVu9q$8eWlg0Sex3m*>bPerRJBeO08a$#1>slqy3Kya133URh&sp z(3GKg4E(C{uO?%+fE_}H9sMwC2x2zN?qf%eJx?8w!N2{|lWWIQr!p^c!VjIhh|aa! zl+-J^j(b2DE9h1jQ%0dYd&rnQJ7{AUyuJmW{EB<%8cx!bZDPzj!ImuvZLJ%dr*3Af zkjX@7ZpJ<_>Yp^o-}IHz!}_^- zkL(#(59T7P_)t!Ek`4Dtjd#7TY$U>$O96J0jCb2(vtP#p_vWH$^ja_Rj?7FGy;zAt@}!- zu2xx;y|Lv^u(XPJqt`yQwW>bjvKZSWy$9Twr1w}ve2=b807*exxipP8a%`Kp>#zWQ z1$T1mtFGkK=j{pZpOI{AJ92!1=Wj|U{f5nhLcu4|EG={wZX1Q`^Urwq&`+6Z_#)Yj zad{pxV4dRc9;$n^r9)P!{t6tF8@_e#Y+Gp?N6en2IKAO(*I_r~q=4qJ5xuu3jXL)w z@_R$Szo&0r<;oN=;8FYR-W7uxx~#95GGXf%M(ujp!dJcAAn&W;TpWS&b?Tt99K}x; zK2+n(@gs0MWs2xM_6wYZ^RvLw!}-7oxGjWL!lr816)#e&5AjKv4IS$-C%tMZ38k8#dKjL>gIaONCKU zKbVnkJh2m>G?wC<)(Y0q9NTJH6_EJrs?I!Kvr@Jvp+!nx#TU@vGYA}|mcFV5U)GI1 zI0e;3hvxRr67esJ=DrGR#rt^8d!+`#f(4#rwVn*h6Ea{y`i!SrzaSjHAJPq3XSBc>(vls)J;;UKG*sj)tn zb1d=-#Q@oXJv^t_E)UsXqV~zK!I(6OINzl>2>Gw7X>&Pfmb2@}LB0z#_FRyM7>a zb%r=q$;otXeA0e(TtL7f7z8)$QO?`pu%wTYmt6V#*O%2g$j_9l*wad()IcGn5 zTJ6|d=K)(5^lfeu3%X(Z4w2v?bG<)BwM78F+-|R5PMLzmj})>i*0_pRQL&GxbR!Xk zWkjJk^c{r&VJxoZeMB_z>+;lW z;xUV5MJ=MbMqrzeobpxRgV(vD(72nl%)#eYK6|FD0+bi)Jl)6%oYx#5^E$R!JrZ+$ zmz3cm^^?3FRCD^Fbqx5EOUaB63i%oLXRU|J=%Y*NxCJfGRPSf49ABszJ^q}gask7# zdzQs+&%me^5z32rGBwq7oo(sqIE#wa4n)LlqI4gun8CFHDOcsaY3p*-6T3}a8I$aH2hnm2Fr%W30Q-f+BE~+l@_9h6x2z8}x zp~H(>^oc{p5~pVPVdPD2qr_bydPkD`kxukARDd^1>4DGnTN$3-pmRv7{VAOGUw-4u zeyObwoqFKqyi4X0=1_BCzOf8vyBeLQ+iy>m`s}<>=JG)=K_=KwQl)F~58i8%(AQe zGOTan6^h@Ow2St@>imM)Px4AtUzS!w?{2<*xmGr1gz8l)##p&S%qjpyn0zbnWzW6G zA+?3XW?tc>VgMrSJXs#pSlNI$ZPTDNT+a}a-ZUw#rQ?Qr9s<279rYMF3@}{ z-@~6Us!wKF0=~^J9O?@=h^&ku-2i(?bZ)IiUG zdsv(sAo@%%4~T`shyDJGUFtG-=jwv2p|BuAf9Ht~!{kqgrts9YHr`^3t;ys4l$Bx3BEf#(@;ILv&c{j=*`aQFA9S-~EXDNi-g0qdzX=$?gDZ zE}S+~Y6wXOeEC?Bzy7#v@KOqLBc$+7lTVdTx##sGdtt;J7~g)DN5OotK4f2nw~+|& z-}nT5Gv%-P5|ORRf9N;^cj0#;^J8ic={`)F!~fmqeM9_be~agh!#vv0Era8q>w*IR z2M6i@+td9Yp>cx$`?z}**`I7?RNmP<_Jepyqa-pp?Q#MZTa@gLN+?N5+{Fa8r4d@NI zxX;&Tc+uz9O#T3QJ+KcQv(9aoHxf!#FRzHNPbVr4*qSJ3pg)X=y|KabR=-rkiWM*$3YWNbF zjOeb_P_g-J;1$xleX#ikNno7{*Ii6vy!lz-oZTia%367~H3MaCPezdVJdaR^b7@?Ca!0xJWop|Kc;xdYSrGLL|FZz9TuTN6j@3Pcg z0{0;v@i5H_cc_~v|oY&)gT--Abj0cMVUQv-+!q0Bg`yV-*7;9I<3==MY&bpuj- zg55GuStUwoVRIQQbJRWI!vdFYnC6jsd0#-EcY&0jl2=>-_^u_8K8#Rf?L2L(bY=Uo6MnTB2orTlTbf(+rH! zmTz_p?TZE)k9W$Jjgu3k;Qpcf{vmzEhyCLn#M;pJ0MQpc@&{28Q!3GWcB}f?is8AK z3*!#iyN9$svX5lwCD%I5oB9R{Zf>0Slc+?!>`1whW?F>g?0$v)%gfGN< zsv!0c8`n>SLJtZ)L~mutzPm^--4T={SpNQ zL|U~g#*st%wDbo|Gj9wm%F`FVS;lRNk#LVH>KPej`M8)nBu&qF4>2t{=K0c zUhnIkz6b6;=j(0q?~hxQ0A-5sx%du-JmIh!Yo4j_hJXtqSVP8`-`!Yb7qri`51nXW zRkjvG+#h#z+U%&+q4SZj2sdDk$-6fXx4;MlVNefgAhH9U0c&OC!n3skE`HLR%L`!B zx$7JVjbE8CpfZ7iG3zm_z+tk9rBGTUR9K6YCkl5JtCw=5h7so~ZN?=vKOlGw{b(TpO* zCRxreKIPuGXO0_7pUMn5j`$TdC#s@s{U5pg|&c2h%Y)YX}X= zGg9>RzG=8e%OB`+a=ekEnOJqx4SUE!{?01|%W242yt3v}j2}f|&0-*~fmyf&s8J~2 z=5@YWVf@;MDt{hOay`29fN|8m-gagGbs#eux=#9Khg9NW6!&JazS6iUvOOP=l}vHL zZCWER_^%bZS&Y_tK^PLaj;iOnu`!pvr0S1yeW2Rcgo)ERE*{>#QTAkOD!WtcM3){& zhE3cqa-*UK9lR|9eYPoemHv#g<9l{A$IPY*?EY`Gp*01@01~RW{R|M@5!*u*8{#?x z=@B+)s_TA*J1!ag843z$mo|f9;#erOWR9QA4>AfTV>9L>A4B0bmCFFRT8>$tkEztt=3jgGe!Q=fINn+G_D6D zBXt^OQ=&(ebop`zh%ro(+LfBIG~Db-{bM1JirF^166S@qnG4i6wlI zdm^8SLSBgp;BWko-T9CZB#0@5@q7|e|3LUx>Bn(>BDpWp_xb2wN&&`>h<`O?hE6nO zhT|0*-+AOgjCbCOBj$6YopRiitQW_Z=#s({gC-yno{`%1O-Y*czg7$jI<0xYi(T>K zh+bkmC-e&F^I#B*`jD>u;B*S0==KIWMD&SvDZ9@Hc8Y#+)IbhIK_q0_13*d{2YXQl zQVEq(X@XXBxMEkPV^vR#ma+55qUq4(^Y8}E%z|-Sg7)}?f*#(muRZ{TA8;QF;{Pln z`@)8cvsfUq7jPei@?C@8?V|iOg}_esP^$5Cwe(*2DZ52(N|$CW-eG~y^v;ns(8c<~ zsctdNb%&^R!LIU+LUiyz`Us~!@QXJ;-6j^g_kWl~FZe{G3I3tP{Dr;mv2WMzC5Qa= z681BOX9uN*^ezl8h`LW0)iEVCAiCzqw|rKaIBHpkCP&F_6PznPBf*}=2jv9O$2Hw-ESN) z)pFcadCV)y6NjeVf^?obVHPECh^`K8W~2%K*E{UJ=;9ETKbujspZwzgQ^M4L-i-by zW&H1UYjxZI5JW%pq-kk(76mOETQKSsM2bQKTbKyZH}KK`@XBT_-9hA5UAM()@XDK- z7A@D0^Hck|Os?X&2IjZzzI}ZM-2ARCQc@dp$f3g>=WE`7oHyiuZ@#}?Q2Hl5Fvo~Y zjCIToJkaf--00$}Jh+2A2Xs&-pEyjqQO3I3iLQ50%x_?%&?bX4oD^wB3k@X=jz~1( zj0s!}k<>wlBZWXJiMZ_V2*H;hvslvS=9hiTDRi9*d&TMeWp z5OPm?H8jZ!{VOp&VYb?7m0?Y8f)$?R>@-DZPEO0b$=7R_{7TZ&IbI~OL8yUL)a#z{|_U!9J@Ih0ol`A|bjAZ=_vj^;FhXW&SPB&Sa`gkulC?b&W3XGu=>~ z$F5p#l6(#2$9jo}4ajuA!a_!ev{xA_;E!{wRbg-uv>{`v<4k8orp*pWZA0GgMk}G7 z&p6LAK)SV%W0h(yY&nlS;UoxE)?JdCFw(r&u3GWy|6D4M2bL`OT3>-wzVD6TGr{)Fi13Q;W#1-`(OpnUZtv9p6Vi3!BBVR ztkJl{JvH8*T~h34ZFy>TVXsDF=j>E)v0*(?>AVg1f~iF}@;FIlVp5S;9cfaVn6bog zQOvd7oIXRFMa}7V1jF;t8&K>n=pPt?l!8{f3k+%MiZMDlrcvVHlBe6q#(!}(`3EVbTLs`cF~Coy&1mA1QW@paF4H7^N zx%>>FZ79i((GzvE(J&*0@fb;0VIR{}Rp!3Sh5}3y;=8G$n`L9d-m@qTD{4h-QT7U- zg9>kQ?zGpL;g8GTiC9Va1XI%VL<9y`U6#~QgkGi*`?aP7SU;As>S4#VkZpDAD%spf zF@=_dDhCz2N=vRbb}j)!*zNIh9CeSweiD__ETd6WRj@f0{x~E2%TQvXAZ5S}9{ktdqW6JEk|L-iE!?_H`3 zAQuAATUDWqgpCA$ymKz9evdNe&&n6blV1#g}FpjQ0w(ZRF)y<|NWn}p{ z%{_=rh=hI|i&!P5w-t=D6OKy*9j!biiF=QLqSx?-tTyqh45YOQl(h+#O)=y&|J0a@ zU~sfYtH*Z{68KkFT)A@ELVH@XIj3DU=$K`0&Twk|8qUG=kEpQF8_&D$v6+;h_?7B4 zEx-N*>Ur9};EBG_bGXfj!G*!4#GhfRh1{D#r!vwwVm_lQV&b0$!oPVkeu1tJ#N2y! z4m$s6;8*UPv_AJ(yt}2eXy*w3Ar{(EogOKvj8(D9Rf|1GmcKM&m8Jn$9=UCXt3B{L zo|tD$qZ(MoF_=AeGbR4>_=d+lKsoYpQS|8i-o<_$;hH<|!SCbIMjqNaLwQDnuFTdg z4i_8>*=4zdcawDeovr!qP-At|K<(ykFslTomjm0JI3uK8JHeAS4KukcaPpzqPCu5Y zm>CDMs83m*u}_MNL&R@+?mk@=r)R!xD8t4(qLEk$=wqGwXZK(lNiOYdooDV(luX z`6nQ|d-bH}^6PUZ-wt>!90zJEypmMQkq!#y#8pQ^NLVkie0fIkFvx4_)ZrpQL@_)) zBv4Z{M>!?h>YonsbbCt4)`Qgb^->#JLnMoTnMI2gIQA1Rwo(xv=(>u1Z|>honVcFHunaD;?nIm=T=>~e&#rd$2j&- zVuMR_IQ3C+wsDS&%zBh3u;uQ(cK_?S28~l{{%@JpRl3==mWD7H6(Vd(Eza}Q7TC^9 z=ZDe@K6T31#?i2Q`Nmhg4uNL0%N4A(=)31AmTU_gM~%7f8*vt@$qzK~u94G}c$J*(Zy7HgK7yyxbcKaiQK*u;{k^Uz{gXA2ht{ zO3_W^x!0;&uz|i)&&HGOD=vmJ*cmE`(9Ql!JKx&at zr-2htTrz0u%TjOs%09CIU0BkT{7&^#XI*8Y3@dJJm@^dscn4cm{i}IaC}n*mSvU)* zF;aFX=-Zjs$Xy>b9M&oZ);}YdPD!f;J@N)N|#LFE=B(IUz{?}MTf)U zDgyikPOUiX_uzDpH1zR;0txnILHP%@!FNW{Kp#BD`s3&A3vhVBYxl{){Q$5Zu=eLK z9f9t5d4c)`@&$&Rhu}ZtkwE=@Ur+)A!Ld5n53QO$##?P2=3DNMoqhrbU4xsAa6*`B zGr$^AmD;FGW=D?dAx?3VbInlx2%TCD1)A3mNPed~>7C8VEU#QKmE|Hj$GVZwXz`iv#% zv*1PsB9vsN((MP-rN#-gR5eZI1!$66%Ij`0K&KV#HNQ$g_(k}Vk4JMs<={&!T&*u= zWJr}b_$V{*H%7fq>iG~k*;jj{QsO9ayFRd}>USyHel2Cr z7b4*wBEj`39+4d}V?2~!$Xh5!AV?>GLO|>mT#e23DnrG%9vQMFT`Ztn0Pg+j3gcfs z1$B9{vxmKfx964cof|=81VPM&zvKuRbWwEA%mZPKF~VV6q2cL;rMN2s!y5$`H3d;o zcWcj}9F*6g=T--mbd493qAT$SpJgI^jwW8EeFM3Zs)19)%71w~@Lo5|{m&W4aNm5% z2Q&k(4A+Tu#NkN?fZ^azG4lRud;DAPFsd&8KU)ZeVd2g9DvCcv3PW5=9^G2T`(m2L zKwp%n_YJC6zL=kdEAka2qfZ*gbrQXxSUqVSv4<1S@rvXQIATy2_-f#7>Gi$RQMC8I z%{GZqLTO%s$k#D;Kkpny*1d7{7z75`1KKdh|n&VByC!bKR=A;a)!C! z!s8_(=nfqpI`Y8IRp~e_hEOiO#?jmrBKxp5bCd^55c|RI8#9f4jKTl+i+SU3=!kzS z4Om;Sf)H24I0$Htp#vS;AL8rernTQEb9D5tf@Pr8M}$o;#9?QWAw3L1^p4Bx5Zg3u z7NQpG49x-lDIdVX|qM~KD%S!?$JsPtJY}shXh}_ zypC{A)72SBcL(czaEeR#DeKar0m*B5BguUC#-@j3x2WGAe@t}boiYB-Z3dhF884sw zfcW!ambpvwusbb?Vgy&r)w(U1BVQ)8RrMXc66_Ph{>Z4`!9d_^cpw!zelOypMk-V* z5dw?%18yQWc)cKn5qi={vD<7Xz~MNt<>_aQG`|bg*zfz##eGU9Td#s28)5bj@#6m< zyy|~cn*P6;7ofInG@#7^g!^DE7W5l6kVOj7XvV*&hXsC2glCN@zbEO|w~=4vvMh=O zd~QKs3jYImu`nr2ls%P~$^5;WGdXp`&+iYMF*3>LaHs;i7bvwNjOJ;vKvm%pf@R5@ zwxek|EqM`%dyK}TdK*J@e3PXI=ufEPu#-h$U2O<0<4!X@?LAw|Q**rBnDTOsKei8P zdzZtdNvgKkDAP9@FQ+e*iky7~$*q*Z~s?-J6=Uicu3?*N&Y>~f;q{?ogZRiS?n-F1q zN>Jy5!A(NcIA+u6e%rrQigccQ)K9;@i)?jRO4URfSksY1OYJyZ)!Fs38?6qmD!P{( zV2vV30!hc)Iw++FYcJgIFQ@Cv3b}#7!?i9Ecjy)#Q$$#|U$#jI` zbCN452_L{ zki;GOwXSmwh9XN%lz2VX5l~7mIc)LF zy+&zdLbZ|3+)O1Ln~D@kn?FRp`5*KPiplro{`50?-}y_Z{ak9KsAAjpQ!G2=woQkz zQ)}5?ZQSiw`1#6w`pDwdMc`F`N?gk8`L$pcrUCwF$2WxJk+bVq#aM__fBvBVGV!_n zl!7aNN~~xw|9=5Z|I5VxpIgveRo$No0;ZqbbBOFmrHeD!6G-FISsR(NAXh;MvWH0ZB&}Rdyc;#u9&&!38CU8Z~Mv( z)KH2mlk=qehV#TT@85xq-`mYQ0nlS{&ag2@<{*A|${>ec8e<~JSc!vtF`TH7Ln3!i(0q#EHz~zkv%{_*+8V0xMAdczfLPlF_6cy;8Y@k=vU#z4Agx2WS(;>O(RGk8@92IoYc6mE!9vNN0c&cg@ zDe3C6@;v0 zgzMEnxNG{$%4uA5@nh(&@HZM`iD+tn{cO`lR<%({iLaFYH|BKsL+GZ# zD|f`v!)|~tj3pec`@k&Z1^oW%z`8BVR#7o71TSXiXdU51-M(ZaGaoE`A9{_9O}F}RkbkP z7VMEJV);>c#6x_-J^{%PzaUN@dg2DYM69uWLS-$W$EJN%%v;C>`mWI^_|~e*7iM zYDDUvBhoSlVTUVUc;x?|SA7SXmAKmPx#6Zrp@1yZW^qk{i|tu)!)Ce@V! zLMaKA3KZfaEvzuWDIi3TC@Tn>Z}p=+LvE$(nlf9&>bXw+?#CK~F>hwqYi3S+V_YQI zYw;htlPhOd<+(AFln@Nt1H1X>IpaLzITNP;{rbunkgf>-Lt264s>d8azK7n45E#tf zZzoh+9lmSCR2#lc!`wk1;x^LY4Q1`dDI608yP@>RFT9E~Q+w*J;?A<>Zl-6uS?)GH zo9V7prSb~>t2E&DN3-T~EiH|9y{s}_XQ-8GJ;*k7Ont?E(ND6O7WH4OzXR%;UjyFW=_Q1G{&T51V0I zO{dnGve%xV*IT>Xn-L_IE9)Wh#5YmEx>_{?eU}O&U%5kYq)A>xs?FpwY&0^SG^(Ao zdvkTA=8+8?d3yIizl~x6s5)%7$$8cRk)mTN+-3(Ll@067w*X+Bu^tOJx|^Iq89PtA z_K@1sn?!6C^cN9kbFI2es;Pbzz2-&^<{Fr9i)b@UofsD`M(ni1A9cQ^sHjv-EXfJN zfiA-ei$A>PM@Jg2M2t;;U+CK1-0~W6r6>xM=uVoe8VBgQO1%XUrL6kayI=tq?R!2} za0ELpBt~Vw1Q_0jY#=e1tGW=E?F+|LNgRlx5fByc7p?il$g5ars4EWA{t1J|!=XZ! zSira#{v4h2R$;?T8VfVy@D?$pDAuYhQ9t!&V_P{dj})1~>nZA58u0#9sD^Sucrv=E zcny1Mug|lccvJYDU#q3P@$9tB;_EdO{&Z=W)@aap^(CH;AqlGZCi)Ac1aSdUVsEFG z8yk(dq(#V_lnC3~@*mo#0=NafWGO*VDLzqx)F;q0NsxZg0fxlt$TiXnuf!$MA;hDK z5J4=GA=zhK{UgN8JfB|h01O9$2ld}L!+;g4>6R|Rtnkwt5RfhxGzAC20S3(JuAuV1 zx@i&JoMWlX~^bF(As1^7j_>BP8Sz)AROY9{=$H zdiYf1?D&;IW!;0Hy6iepN`wvMkubWgIA!NKUGwuNRxQyD!+sUxh4hxY&K(d(JJ0a$ zwy1>o?1IXY50VT~F!Aj}zarWUf+X(4@WZUP(&sqvJ{X!XuB5y=;N|ck@x3T9Z;uCa zwW@342M->Mm3$z7av!5bR)!SLtsBXTl$TjIb>ikEh!M!&?$jklN-}=IiHR96yqIP_ zjqehtq0f39;x&JUECO%AUGAi=^=$8AJ4qwa-ttL&;0kpUDEi@p`XEB_g}@SwvJec= zGGW5VC84T&^~`^Gm{I1o=-bs%uqqcD zd<_h7-u0h@$RnSQe5J}O?nqWc9@!TCBq;45!27S%-sry`Q%*kzpR=E4(*Io}>Ay+f zep)jbC_7O;yqteuGM zRdZ&E<}Mp4SPGe|77pHQ6}#S^_?LiBtoU1c$ddp0tE^TAo|nV&S{+(_0=UrE0TZ2h z{SAx%L^L?sZ9baB{!zmo=K7IV3T?_HQb4z*xzD=NBW}Cg z`%iEHtPk%M;YaIpw9q{mV{y62c;dryzKpBDox9Vuw%XTRZG9r>(~bZR;B0knMyT(m zwmX@?QMx0wx_aDMeM7X??v6F-eNpQUSMktw=Yo4j`EB>6)_C7wzsTBbjR))wR@=Jk z(d=Fh+V0WlcOu*Fk6m$Z?}SiyCem*0>$=_^^zbwy-MsWccSh5^-W=)mdWVw!gBc6I zY=HjTE2hU?X=f~oySFO1dQSNBPSFO(yfNnNy&WR%-XHh=5DXsphV1*O-226@mwPm&?Cp_B zKSvN<9z}Mrb%|Wy&VU$2jPbl+PN9np>FOLj&NfHno)&uKh3h9KtOib;Q?OigiqMG8 z;zDvTa3T^JFO6UeLyFKi?7yi&@~<%^*hmqCd;z5{`uG_Z+X}r}TS2SOk``zc`F&HP znHVveY?vZt{#@uz#Bd-rWY}NwP^b_S-X*vXMYAR2Cd()R4J5{o`0dQhtk`5=RioWR zkOavJE|bOq*JT4~b0;7_yDeB`ee&ph?d&mC2V)zHCJv-1Yf_y>M}ldV>_cnGB)5kK zZC3?v8zoLO=y>KqRQ$bB!&y0m)83)p=MXu;l)E>M%lf;FRw zZB^)ES`#fc6pL#sQ|MlGpcI04;*XeVTs7S2(ASn{IVoG%#5QTrsXWfuQ)zP#ucXZ+ zLYZJQ&d4+LpDUVN5e|$B*jDhYp@?f1de5dN!)_jFR0y&ZEBmnwf9wTW zu%yH1*9R!%Dal4c(>-aanN@-6!y~SAF@Z{nacm%Mh%rWmZ3Kll;O)hP7Gxu43IpFb z6^TVj&vd{;kfD}Gd?pwcmubJ$sC5VVFOkP1f0;8aC3G)yvw*JW@eLujrOqlvShw4E8kmm=RX3Rd;ag8wn(x{c#` zV$htTNqecvJEGF&{}x}7O&+;lTfbGGXlQwv5vlA-VWt@}4h9}LtC&3mhNuxYL2R6p zgd>V3xhh#Y5)4WLFCKd{^ndpDsvGWi`bs>!ijOU;m?)k1fIIaCpxRGDh9P=x1;f%X z=lB*Pu9WI?@yYl48g^7(KaQuW=}I2QFgRW3FRLKqx#t$Gb1q$N%8RtlbX)G>WgJ>A z_ELvZya_DJT+@)*z~OwKomQrM;A`M7g$hC#%+8CemXQ@4LR-%oOc!wJAa{l!L&{ML zbQKmv(Pnc|Kw1}ma(<@|)W+=-R9=a!k_cYgmtPWt_h2BwI$c0BkF4#>^ovG;7f|E+ z5fY8x9Vt%0@q7(y&QgrD%UCi}a!;5UX>lGIOUPv?pQT4ngz27{Y8IpxaUwyD(n2UY zhsL*CP_c-pdd&wKiAQn(@Uc~ z-|Xm#c~s_P8(Ft0gprGSS%Ja+*odeAfC|h0b=-CrlDT8fb;h;&HicnX416riVuXakj1F z!A_SobrfIsP!>6}C<5;OtD!aHSR_J2b_yeng_VL&>I_>_;GuTW2%40WbUWCwkFkFXV~uK6rP9HF4~sno!KvVUS}7;1q6yHXQ0;w2aS^K^UL&XeB&b{_5?P2b02`+gGa_qFIGeWSGHTLYeO5K~y*dCk{ zkwm_}jdO8Eksn8ZUj-PC!tVB`@mm}h1=?of&hY@#P#C%g$T3jLXojyA}6(*!D zpt`}vDrz(uZy|GVy=$^kRrN8+=_ZhDUp%Ey8u2${RKu*BvzcMq%gE@HDQ9{J=8Z|) zLLYUOMW6hNNgv#rdC##u&@xppD$d@K-=_oE1QfUztnJ|#4A;+MukKD1m@Yut<*Oy2 zZ(#T0jT`tE+|RDxM4&b+htD8K)EiQ7RZ_qk^jAQ~(y#%nD4+TWX=9trzA?&wI&#$bPtg<1ICy>@hrP zUk{82cnqu7=F))>ge4i1~3nZw#9Lzusol0oLd)EwjhwA1P=-I*RY@Q!~=$J>D~vJzaM^s z#0~Qe@n@x9ifze-LvJh&_Gyn?MGNbVy?v{{?{F#^h9=yQtOf?Sh7t}53QpXWKg{c?{#tj%RlBJ6lWdu4Jsgfg={GPdo2hWuriBGks|JOGwVFP`nclG`R+bjy*0^%1m)RB+_1kwxb$j+Bbi z;4~v6MP#}3r_r|1B3jr2n~0Q#SbL&w)@CMG2a4W8mz5F5Ci_Zs>T?a2WZkK<7j(7| zqyvr=A+b8VgMI6`1C^&AwX3S0NNI61UPQa#{l)+5!tN)VPBZ{DGI3aaTnGn8I`{doPz2$f*~D>y?~*u%=Y) z47U;G2b%D)AZ<*m8iQ3S2ZvBB@}zGGVTZ?MA!@#)7Bgt$0|XbDx{HO@qI~6?nf{^# zMF%IO*x?RH;K|1E_|*a*Hd<{-d*yc_7LQ>4y**yDlX0y`n$O^a&EBcy!*Fd9;r=QO8BWlf!Bu~WFS(>-$a=sXAFyOMJ906aRek(mP$10Z*hGayk z*4pSoDe;Mglm+cj9_hMUew#s{O0Z`tMj_fIEH&u9}KH(hZ z_L+3QN|E%oEBevhD%Z`wRtmpSKZ+jYe}1UG6$Q!s^x#{TODA(`^~%Vl1&Yx8$>Xml z9W226zahSr_OZXBKY(cf*q8g+D@@XP_r=;HZgwx8k4!t6|JrFeuOaK)8^{vWF(9vi z%^QT|YwEu=l{;Rd6~NmzkfC6cr^PJQpp}hTbO+ru0fF}`yCZZ541Vi_$Zf*MTC48} zVmKg(saXQ%wRYVN*4>2BSn{6yg_n38BlO}gr(B3MuPi+~MXrir0HPykVIPp3hba?= zm@Gh@^_La8Iww=6e4+U#X=~et2^B1UK-;3WOdF~uYvqm{&qtMBakm1;T&escas4}) zv)mEKC7msJtX*6d&R!$-Xip$VceW?#>(B*x0oyuC+2RO*;cypj#$E_VLb*X_0YYaX zQ0tKQV7}a0jH%U$a~gl{@(`iD<*uybt}N2Ro8nc{JKQNO=(E`+ClHB`uwo3k`#UJ? zXdEB?qj;!36KqGNr<$V zxfL2)vAwPENH2xhqh(*`ZUxbJjD^KoMa0;yf@*cg$5Y4m++HP(x8-ZV_qs@UoOI0s zwlFCs`fnAHUg~4=lpmZ1gGgd>{=FQ!!7p^(M(L5Qh3z9stMVgUd=p9%oWzC<2lW&b z91%oo2~&+8!&HSf5~pNpQd(=AKXKj$JLV0Q{e>Md;S(24iS_lNkEW!2=9~of?ZN&E z)9(iB%I59DSzmcPAYSB28jxNy3!iFYsme`_98MWf>$4rc}!;y#V+AwVkEw4V>d zWK>O&wX70ULK!*&qTqE_cxf*YChju6K!~2ukNk%2AZLj=~|Qr$pli zFFNd%63?l_lUmI@~=0gDrzwbE%_=K;Ik znw};xvckDMMJ_=7Z`m$nlE;VJ(76!5>OWG~i%{*Zsw)DNEnpg38FaLcCwxUk)#)0t z(nUp~{=fqziGP$e0}w6)Rt^K43xzPdj5xeX0bmOU(gg!F+98F8)a~pbqmb&QOyg`BR1$w0-0B;LZ*;&>Y(zIOiM-G zLTRr>{xbq_TK~-w$@G#WEM6GV$1^4c@34q;54wU^sJ7BM{A3x=Huj|Z144my=ky#% z-YE?qbq&xsGQ^SFkO&m^xi;BGyE_SbTu58*amvK;>C=^m`@n%?m+DtEvP>n5V?qxL zYoFK`gm{`>;2HD{Hf@}__UpY6} zP=avza;$|BPl~-8ljvfKisWB8-4sM_-i`Wii2&3(7H)UInGX z^vEfEAPb(u1}SnqMc)cghM~l0nv7k~X_aoB!iEBF=M#O_seb<+sRdn&*Mi zHmM_Nitcd$HgklWZqz>mdYcjNeU8c#;-(52B+i7}{5` zE%Yck*WHB}*TtRHP|oUwaNuVhP;?BBK8q%pF1J0 zZv$DwIdsRdQHL!RzRuhK6zn!iHzT}8ZBv; zvJkv%NAqGWV0+Px=CX(Mz^W(&F#+OCO75x3g(^z%MXN&X86TriC_xnnQ3hI;V4P5r z*2`qTR3$sMD`Y@jPqMUYWWc3SrqnBEK(bRd?YWx3ZP!c(eI~!(0h<8gsLZ06TA*JR z4lUAzk%GZPHR(F5zL8lBZH8zK~!9X}>iHSwMo*rZy1h)1n+ z0~6nN$a_Sg7j!?#PLa9|aXi_kAL__FlBkt0*MW*g?bgpZsnhDR=*cg!&J&WmnPB?tJ)9w5ix-hWgrE zCfkmaULa57!z14vhN#~+gxKa4Yl{XyvN&;5%#~_ZTH9m$S90T~(0hXA5alGImY=L) zQLx9a#r0{FnLR)qllV5=$Gv>q$9&jWs{PuYZyiUNq_p?bP(Xhft}kf#X4a9n91%+W zO1KE(QsDZdm-${KMzbHtIM=n}>$+{AQ9#iyaV{Q1I7p-*6$uvBhVD?i;RC5IN;62q z%9n$M8ITP;&Ivhy_t7YdM`=hdRarsGu`*_6cq~Oo|l9Vd0!r*u18GOmts@rA|L%v9o`E(@~Eh~Zm0Y1(Lu zleyclPiV>8a{Qp9OSS?5bS%&6QkfVde&nQ{7`16Ae!avo0=Hq+B6zI`*XAZiYaX5F7_@EJ*Og8x>4(w~1Px*6Ny;9PS zg(VMs<*C}) z37gAB5me>Fg0cLimzCCQ@j*TP?MlTIY}Zb_Y+`q4pdXeP;JZ^sQ)I5(NSS=lFpj;LMMZ^aeQF~16` z?J+FZke1MG!<#)6C7Xt@SE=qPRS~M^m_d{L@C6L#;YrAl9M4bXaBv~tijv)qOn3SA zt*`4P&w3%=*OKo{g$`u}ZMd9G4SPjQcu_v;w&JJW6*=!zg}+)J^tf_#kHv$>j5w$f zd}F6GmPP=bKWO!5EZyB1XbeoN(-no=uNrW8T?3j=_ZDNT(UyUqR#TQ($+B0^<_gEP zE0mq>-G;JSm2>{8VJK$$VD_AaI^omJl&&{Wb@|hw@a85aK`;cb5Ojz#yDzI@)Yt|# zSYkk}K*%U<<%`7#^=!h$SZ<>!WL87QhN7O8F$ALUoE*4MU#i})|4Cx=lC3Y?gHYhj z3(7kPk0qBS1I?z1b3_u+K3W!-;IlV}PyGT}-GPF87OXT}eE=*LL-fHNbbHIFAyJ{m z^gdg+>)9(RNrR$?(6MN{|_ZIwvBg0o#VhO2uR+Tp2 zH6=l*-Y@YiHLg}y=ohf%i!4|)NtAcCq*`dzDrpK9U^I1^4>mPFObR6rcF$1Ir}Hq+u-F^y0$>4GGe*zsyz1+mLey{$#zbPGWpS6Z^STT&M~A|?4voAKn9 zEaN9XdyhoAlr|x#TVVV_mGSH%RchBy^gLHD;sd=}e!HpGi+x1HJ|5g5NH)#NWUx9F z{D&IZv_&R;$z+h`yy@XD!O{^}2HD!WS}!st)Hm6f_g3dcTD2LBhUZPQWwx4wb^2UZ z6PsuhyU&`Ge9xtJ9Tux2xj zR>C5c%g%r3sWfu+Q|Od#5#4H6&|RCd`L=lF6sf=`XSJe5=#y^o&APycZ@CuXII>5= zB4yJK6;v{DNO5AH!hwPPdIFAguXU>+jZ#Xfv>%B{lrr`C(cr zcG?*QB02dZ`{6KM5{n^P+cyo8_~P7+^~NzBp8!X4U5I(#;+nFb6NU_0WiNs}Mc_$QRcd6Uxv)t&$ zY~t3!9_w2+t!l~+fxLAF<^E4rYYo?}E5|Vd$eQMgf}AotOVegoK?qb1Fv5oe!JMYe z=BhZ>O4+70Lo+AB{E2W!Ykz12sh@bGW$I@*G$*-s zN?FS^G)Nl&QAD`MT1H=*FojM*~UV`g3> z9%K%CjP52Am8+0y9k7pRNN%c_+FbZ4?@^37Dc?gk_M1gWQgC3CFU2CgCO*?As8D_6)WljF>dUO7BLQKEzry6mHEn=knmPGuJSoo z8{n&Xwn4hnB+)Mc>aw!JF?5E6 z!m!YevHm@hy1UflpGwQC4^+4+NDtyR+*G&+MQn5~FZY$sgnp}R%J@Z} zEQsqBNuRdk4;_y;pnAD;4t3_cz#hxJ;NB%3Mo%dw9=>M82?JtzMV(b;)FuRqW|o8x z=1}vSWK4^u4`;OYiD&`JEo@M*j1(&e3I#6x)-_4dO|Wd1Ta?v$KnB-JOp9>g7HQJA zd?_+UYI3M3wCf^Vpyw4FTEP~4;}Tc}xK$yDIL#j{JzK*28&5aZ?E)BL$X*727rSIv z+O|~uusE1ilusrfoH#^1g(UDv${tdX-{}TY!7V`of0nxfH086l(bJ5Dw6gwmReWvBsw%d z!!~egHm5or5pcn_6Ag*jBOn(*=$F2yxTm(~!P@lyYVVg04niW{Cxjy#I@^_fiaN(F z^#lQpDRq*cy&879E%wCTXr1eVS}8horX)z!CW89H1W}0J34Lq@B7PjMmbhbnJ6Mt5 z4Cee#nA63K8&3{8000^j007nh*(oCE=xE>}W8vidUnY@1(B3M?Dg3)VZYQ%cWC%#6 zLg~RW?xY!#Fd&%%P!bRX0SF0cK$;kdgqRXc4ov$7RxPyaVVYGXwdKzN@SAk4;Yjr= z)mHenHf~$CHdfcITQxrGVXa+0;i65ykAJy$w`GX#tkU$_U%Os?~MP zqs+q1Yc)(3;blE1T!{btdKWLmc{c~@z7#$i^?sGb`3mtLuln7uF$5hzdcC9e@EW-y(Hx6J}=mvwQYa9@gY5V+4hXqtaUtt_kJbN{|=@7J}=~*&24`` z>-|iovA;Q{(%XHU**Vk2?G(1XJ7Ay-mLl*~7N$K0lQ~zD!uVb@g>c7NhD@N#=iWi# z>pi?>;V*@IhZBq*N8A?z6h=aNQ$B?g^~xVf_oE1YhwktHD@$7^CVMw0?6HhQic7yj zB*dpR9br+NOk?Vm*_ZC194swIP-%DGcsPNzxom5-Gq>96Z0N8VViGhg$^S|<-WA|l zP20h^#EgcfGPkkQ+1=c3Z7K1Pb&|gPkUd+iWc~{5_6g$Ub>%lAaKN?w=VtF_-$}zm zD7G1Jz5$Ks74b|U=&AH1_G}^HUa<1kDx}}xTkqn{)x_W031SbinTW+Wks^KD@U1)!tgT#4>7I1gWk$TT zh~*GE=;E`ODRCQF3XH7OtlDxNbsf9#H1yF?GEZe)Si{_n`m`N|Uk;5w zo7E!(3B9BGSJHx)$KC14%(W#jB-D|&Px2PqkTIe5;2)t{Q*;vG`=j!;IUqu{V-dyE zPb80BbZd^v^Ih?FBjSjFkqL~sPy(yQ#5U3EOtTOc2UrG_X15FZD2XbPc+Gc_L|H0S zJ#BBLrd;Uq4kwK*K#xRL6Ljrq2z#isb9^GdRp)=rn`I^h#QgXjFUPcN9H<-*fa6h z!76yg_OC$!%Mh3+L(W;n7UMcOX(~|N082!y1{WQus}?hKrsw`oX?iH&Dp&lDE{?xP z$3h~GF%;UhKPKA~sd5g@t!7u#+=cao8jl$IWmK7;eLlCes{P`X{EHSnlpBfilp*fl zG_9fPw544|*;t*Rp8I6uR&FwWh{|?-xAD!OQl7d?#fL@V}afj;A*(D+%!2V zy!!POrd2}I@z9-#Xe{)xs|t5Ehz51x+Q8^BlfL$QvQf5I$Kj@oKvx>%knio;hyFeB zm&gDU9)%GAN;@(PvZcS)hkN7Wopt=kI#G_JG~qOXEq_bXZ5x`mB3DXnfCTp$9q;Kph zma*0AC`^>oOM@Zv5)ctx%^|LeZMw-)HDJRHC6M%zTWR`EV%d6+=~IQ6zI4?Uaql!# zt!%I!Ts<#&ZVslw`gR6xem94z zWf+#~sYFuo*Oa*UZi=P*Sh~Kb$*iDWTFAM;HVUR*Ux&YHF&4hz%D@7XR0|q#%R)F6 zBELjgBJNA0@DA#$bBsEMcpdoYoZr|xim%J-m7NmimNSah=xGyOd@W1+_%cdQzbv(# zr|T^%hvhA@oR!%fAkvmU;&Pcra{4l=cTdURmb|{72W{^QH}A@?Eq#6$3bJGx=ITwO z%ZAVR-rN3s0qF6`Dv)Hi2zxpH)faD*23}l3z1${hW+XUx{kx>hEZ&;Q~J1wZa;F+zqTO)l6t z?_szJ@vDI=O^kHuFH)*mlMUTr^!^=p;C|E*lBz<$*ud!q^eP%;A z5(3RG_p4VbJ3A6 zbXgamb^FJbnrE<6n|_>4HD5_L;J0O2ijJxvr5S3(4Vy|P#+j$C)b-h$6V)*}%_i8} zLp*=12hgV;d9M>u{&8FYn$@znpFQCz>Bv+2rDu_kjUZEA*Rrr`{y~e^0@-FX$85uJ zF0uau?51E`(oy^g*;s6ld>k1P^tF#CCcv=n{#C}AoLBF+3Pxk172@7WAJ(9se zAg3|?KuuMN(zc-sOUD)KOJmR3j1y?%l$dlF1-(+hh!gs@K7D(_=;5^p%^0*;@it(K zzW)wz^1l=E$YQ4T{UXCAma^E>g3^fkF2xz>q z(7(@Mf!Q2ZaX~WkO@;)DhNuJ~<#-AA;ToXvuZlP?3wq>C86P--tW+-kwSlf?@}sl|8@exNE?z0adJhQ~%hl z;EXa#eTPMcVRrB*f{Y`4`Mt%MlA>3|bz@!l9_fp_*G!H^k_QVV5>}x;vk@MjJA1|f zM8>|dink1{{`oxw3I9R;Es4plWO@|jZRqb!V(_kQ441g5SQMly#B9u!OWFbV+-Y2} zoS}m`TBR2acoVt*24siY{6*F3!PFUWn>yEiU0Mvth|KCpR;7_e8dRDmUjP^1 zvw9VU8QkWDLo{mZKb48i2BwI~D3~^&RdqY#p`Zd}-gw}-I6$fOm{T+eSkV&w07x() z9_wti-56VMs^yO;vI%nr;9`I7%M!uY)ERE+Df4_qMW3h)&+PVd>lBH5L`mF75;}>VfU&0_CxsvB^#*!Y6eTD5%*n{G{;ZW!@ZOS;7ebY@Tms|_c9 zW1~MacP*E&Fhv`CP#Az~22jasV9{I*{kROVH|)a+`@7~Fs^pIXiqOvV1^(%x$_m%2 z`8t$X#UxG*xnYz0?bZDpBwX3^47-&n&MU3XbeVKZI8nF+qgyPq#aY1=JW+OmeAOU7 z$uk=nO8VzcIj~~=?d0m4`@}$<7e(>52IoE~34o2sz$CiwPcq3g#|rh5zKITt z28)!&Lfh1YH>yXdSrro20p;pTqz72;_iEzCRqBDOOJnnff>!6IDMrS)zr@Z_qy-cr z_|x)PCVQ0uAW@SyMJtOhIDL~$4c(A30KGT<+)o6cQrduS8*II+H5<2J{e3kCE>hYB zjnQN#MJyHoDkO>XN16{2C^5(u90vp`k$+iKuL8tA%OPJ!4tkc!cEqtqo}E+b8&go@ z8=>Ha#2k#qG^i+z2_)Dglo=4&sK42%*>`9X=J$rJNRUz|q$Kf2ol8*-!GiTK5ql&@ z%naNG+o+&(hp_mz)0#Te4iEky1;okQ*q_7Nwps>Z+JhtPn5_atiOG|k1$^$xA_LV5 zA5}qk!r>96`8xMu(>*38j2MzVXdvMOqp<@=X_*JMqtZEHYo8!D3v3HU-F2&MQ@ZFu zpH>8G%kaTF=b02SV5*p)tou%-+)SlhXPqAkgu3Vnv`zSP17Z)58^g8gG=delHHrxS z{56Ik)HsGZltoJI`kNpqlnsXD8{HYTK>#@@(}5W=!eUO9#Cu2qJ}5>^h3FVXrfhY0 z2D{_mcEwOr3F&@`<+G4455&T}$0y<;NPGq?L|QoPom{%&&l5n#ya&2~ARl%2f;dUf z`06FnkNos+_CX`bkG2XWA|^cC`;DRxHeBz5hYj>U5$b&~c)U;y&Y4;Mc%x}^L)G$% ztsFe65cdkW9AL~Kj|IFUH|u8S&m5493{!4G`h1QoIpg;3Qsjd2<`!uUtDoh+QT?UN zO>^D%_Cu^U>3Z99x?ZHywP&KegasC?N#ld;{;L8kh8N5#W9_a3p>yr%)F=Jtn$Dy} zUW%`2g^#YriqVxY!%mTM$r1ITXCeVE|J(6|esY|V{In9m&h;RP{t zdoHv)tG3S_8m%6bx)}8K$FFryj6&eRt9~!4e(%+w2cJl$4`k{)+%!C`Lh38sG%8P_ z=#8=ljlam{;Iw|5dYRBy6!M;m=VPo{{wvoOp>7HA9=ucaE5R1oPf5*6MJ3EwW*k6sR`8Lkz5peyWWjk}&1~ z%O<%6f*0hYBVO%|C4fYvh-fB1|D+IUMpl^>Ue!W3v*>uin>G*4>abijOCZfkv>9@@ z&2j`~P0BotEd#6>0oGDk#l1?%U=EBCF;na64o$>kdJlUXy*72vDSo%8e-{|`7EFRK zeG15r2db0ijTvJ@iM#vn&^XnZ6%6!ylYs7g4|>+>%(P^4bH=ZPrrYiMh}kh{lzdI@ z_GWfp*V|V!6(2reVf6XGnv-qo6f!j`7kt@iG@4$8{&DLYG4gdpUu)yULLDeumLxqZ zK=M>22`xERO=?#2Dx8iN9@0x5Ej9kYB2p`aTDQDPWf>&90j2D^?K+X0AWNQ^C!B{OK6b<+jL605yK-k)ZC%dmu8Y zUsomm62Swr;H_7rKemv}%-4bDm*hrsR@+n)I|p-fqdJ)ssR>8*Q=s(?s(FjPI#4=p zRP>A^oQ^>_0Y*3xRw=;Ex7ZZN8Jt%54<(;MF~@{(Mq>>inO5n9CFk|+`0V zIb;Kdi01;vj7^E3DS8!jT@8&}FpXbCRg<*S=;M?Qn#=zAtBkT>(HE=#t~tAq_X4VL ziBavHE#;6`$y;%Ohm1W12x-b!?GvJ-ETfDiUqt+b*%2bsP?WB!Y;LE;3i?nV@%HuS zBb(Nwh-XYBEnG(+y^O*$S`25=LY~`sR$bisS4R9=66;Es%Wu?rozU_0t3l_I}KVq{Yqj)=qHy_<)$1$IR8 z9sMl5$1w`G^zrJ@VxImqThR+tn1GN5SDvH!}?D-=&(~!ATbVS;D)u#r%*U4)9|TA05`+ zY!N+=(9So+#gHEL4A+?>$#HQH+|L)H_cyZtJ2c0q`c=6ZqTnxB7_WHBrj|+_?2`Aq zXG84*)ZhFn7xo@;cFIsY9nW5sXG;>O$A&aMLgOx zaOSKlC=OXNdbf-7WB8;u2^rwGD%nI>#qYJf!aMIYsH@&K%M>7qu5205E?~iOFF;s3 zq_pK7u06xi9IV)MJ47Qs5htk~_@xgJWJMb~cl-Htc8ycp8;saJq^6PPC^MbHx5Y#A zjGkN~x(FTY%81el{12+rWqg=Co|UNP%M>E;O6&PhA(x#i*UT2RdlIppEj6peEwXf_ zyPl*eO6Ce*&!3%xb_DR}u@RBc%4JN^x1S-U054H^ZY8yO-Sy~|f!MR%T6}65fCZhy zt+ zszn}TPBidyv=@=2qd{flI;_|*J%het04PZ!J(3$p#ri`?8uNLUap5wvL(asO5>Kuxr1m^SE9psP_QK$%DfjwfrkvNX=;%qxn$xeUS3US}X)jFPLtP=QhOnza zPSH$f>s#udV4fF}^=$pjgv&FmO={0mg(|dz0S3$n$Xzg1obnkT&Y2A292**vYzc)zwB`kvoopk^YS6t&HIjG5gF4B!Ho zZ<|?sTMV^L{fyV*^szGg=WLxbhkR;v_8hy%360Bjwr=UM6woO zkR@i#ZArujUUu~rDF4#D^+#7T$&gaY}U(mUKJcG4CdqqtOhE$Z)Otsr=6gPN} zXsNaD_U^1gpwVzKe_S@w9x{(Odvy)Z9_&?COa1^&G>Lp09j)4x@_egh=I@FTe#2ER z!YkGIlFuyM2L3ao%6GwU9e+3L`uVe6hM{&;>POp2I@SR6{Ky6lRhWiqYhBR{z@Gi+ z$4*zuX3=|*Okj$Ei8o7$5N_fgRc27Ma) zs@r;yos!FZD?VK21>og588bSicspH7jr?4%^CR!}J;FKiJi$-gdyG54IO6nia6)A& zuKT7j^^s`x*>-l+>trVB8wz7Qb2EsMpYu~ZN;lHAiR+Q55KG^g#O0ZRPDmwDWf+)PgZ8S7m6!@!lf`F8w78T(T z8iK>c#X>NlB0dfpqmAuXiPx!nQFT8sJ_L;S!~+yUBm?9|f%o*7x7O$sd%)?kZBDn_ zPB$H|v$HRGc3J?QjB2pB>MSDms>1Avi!u|cabi`?p;l+A4m!fBl=&<0H<^oY*^$X3`O<~eu7)#QXehH5Dw;tJ?@-u*x>aOh>iO$s4Kxbc}qN_lK~`sUEx zhPQr9f$!%YNpqXqb6zPSwP;^UJ5*8lJhRt>NzsC30mRgn_~wtMc_b6-DVgn@>dug= zf9(Y({+VK_JBpmn^lxAm%$4O9SciF)C#|>jOxmK?6yv~fV=z=0ix1J5xGoS@9JFdR z7fKB^#vpDOny-$t?Mov^w>2ta8%%_0CfP19Ms#q|9U=&QzQmYC;8!Jid9}-T#kusa z#iay!_d*GwoKKW14srIc@EXO5tX|vFPTEPzxZb0&u9eIiTOD zC&WHE!X5$F2u392NfO?GS_9^>l7}zoa>yvxxtHr-`AT%5;3zQZ@;M16!9-+-i;~+1 z>k6ps3WE9K`BlhnoiNpv`&Wee7^tv9&!H2_DD!2(n^hy~%D4SHJ@Xf5m?|rE{x}B% ze^FB;V_{GvJ%h1km3ubFUfhz#k+CNYHG)Pyu-w^DHqlpL&fvR^j7boz!!I}Hg*VtV zH|m|4^-X#5B2bu<>T%O0g`(ll7%m`ERT3klfINbRRg`B2q1Gg;qQJcgg?}pMNWA^( za2&#i(MflH$QS+4|Mw+TSwv+S`Hz<3j|Big{r_-p_Mc1Ye^aJCG_+Sxe|1h^nPG(e zArT-D$PzGsBn6O*$oyl2hYOGe0z{B#d#8E!NQYo%g^;#7S6W>oG_k81M%!1KSDQ;w z!wW|@SDf{(Dpzd%p5}bN>++=MIv!7Ej7$SHdgHo!yk_5XcK@ZTxlebz_Duk??&QIH zRY1679i8~u^<4J=KW!wwJIwb5(dkAQf1VK7^&IvLz+<}<0*&N&2EQR~@s3Xz(YM{V zL&)!nk@Z~mDYKmg_pGW04^V5uN`vIt?n zKu{cJVinRATo?otN-*KDHFLJqvlWOU1?TJ2|8cq?>z55Mx2{&jjS?lcv|_-5vl3jz zuruNJZbBlav*?q6+oMc=rJ3>}xV5QsDHnTYVwv{v|wUWzL3 zPk$pC>ebTVls0elf+t55mvLF_0>pkvek)oqeQ-vpUWX*e>R2pa|DxVMG6eb z>aJhLMOmZtC0Wng_?$G`?#pc8aCUzaA-N+zB~r+Xv8r+~f`^N{Qm(g&vR)@wQDeZ$ zL>6FktOFOM5YTuvH{6YKED6Q=zZm<*=t`q(+lp({C=m~2 zl#Q{zWUBnM{eZ>59igf(GY#HjB=7$CZ8;;Zyf3e;0${7U~wg z4ySG(m!02%IFN$)tpbGK>G1S5q~DR3sU-9{o?UAny$+<$`B3e(1*dPomR(uiLOnrn zSvpP9PdQE=H$8s4J!kt5t*)C9zpGNnIIg6f^G__?TL2nG)Ueen9(!Mzxw^Rim;dF~ zEAi)1f8Mq`h#l7*#?8m}T0j*T-RIrJ5PskB=w`c0K4F+^Co*zo$YUhbvwWzERNG!V zx*`7OMgQ*BEBELAD5TgnN53p0fs62A!t4wj&-OrQY7RMi2NB?VQD$=OS++xkqm7|V zx=uhR$**88#0DN9r;Tf7#HdCLU>!?Kwl`J;~Bg823qgSE#rFxh62mBLvivfg{N6F#aF|zaXDc-x%4yvOL22oI5=kkNNT+=SiQk2bqUrsmJx_sb zJWeAxL{U;$$vdw8Cy(?Ijp}04gQD;20*D(->*8T+jwu*Lu?Ga#%p2OBeL;c|m1^T{ zVoz9Ae6|v25-%zGa}0^JXyiuR{FP%PaXGy$os(+5d`8G)^A>J=-7~P|X2oqk0J}p; zYaxp7LPNH%U{u`lHAhp#68nL29guq!FI9QeJuW|3WV6Vx>K0Q_8@5b&<>OStp4SS* z!9daCQKC^+F%w}$%FScg1EzTEU+^1mQB$I4heukzXUU#bjp|!`nAV9e7R|{XVXnZ~ z9bKBIgqfl$NAL}nr%Bzj^#zuSZIk+%^MmU2)~dF-Pn{OEPf4V?oja8?F!Jh*Nn1hmP+r`+;BcyVE(2MwyQm9^enS;k=VknxsQJ(38yi znbtGNcJ%RPPU>-K_E>-EY{#n5wR6a70fQrN)4fy_6n3Q!_V=^7A3w~5OPjPLQe?#p zgzU}hn0#~uy84B)YusOMDm2QgNycIFLGHaCDHQPEBvMm3uf#0 z3OQ!l<-B$Wm`bJuJ?JQ^mL}RJ!nM*Y7{B+cO`!18u--Z&Jcj$bt3AM<31ENkq85BL z^y`?GH=hnZ7w_M&@8dH@>*Nwr;OPN0_!cjD67EaX52Y)oW(A|fpxyx0}UHgv=ru|i^J?cgNLPx%bHa&LS-Q^Ia_R~o%wd=*WiEc_p)u1c){@W`MEwXqutASnAsgXDCmnfe z8mV`m9lw6!#WAPc6BS^$@cz&qhi3IkSi<> zfq0pR#nzg%)hA{7Z9ID-L`8=P#4!R$j^ta8u&M`WN7WcY>KL-SM)G2!u4dK6Kvx%7 zbt-YOSaTc|r%lN^Ta@8a1zhVWb0A`Tjf5OGrwb&uHt8W?`qngYH7?o*3!QjW)Af7v z@9@yVScGmPN)1yC;0j00%c{FNlE7KzXx#oXfQEn?AZ*IKn=}A1M(mSWOS>s)p6ohxXA~x$md1 z@~q#3Yk{Q3zaii3*&|1IQOkZ83T=r)`6N%Cf}lboC_?dy-M=Hg4-a7?k2Q$%1R^;I zy{}~qTD`ZY&88A0jvO76A1fp)g6>KZ$KL+n-RC<0p=A%nCmUD2oYV+=-~)}y%};qA zhwhy`oX5DEH0Uljn}5Aty?GV5^_v8WV4T`};UGAueF||$qALbtgc^~#o#TU4Uq#-S zYW_iUx1HnCQ+HoB3Z-|yd!Akc_X+RS8vim2!)QBVZvT;U5OowrqxBFb^e&-$uyq7# zH^%D$5`zX-3tCCJ^kS*!weae;h#Xi?8(6malqvb^->PJ>MH|zOZ}zX%Z;>t5|D4kQ zgZlNG^Y#B#BCBl6p{k*N!MV9YxI(<4in_t5%$vw#0Np34z?4T#sVN{@uNb&#gQsCN za$_#B@MV;iN-nYVnqwQ;;3SIS$b!a{zR&Yz^!_gJ6Z#4yi+RdkH_%xqZYG)L{k`*e z&wc7PyPZ~-%Lg$Z!3p-)qSJ~(3 ztt&=zTCoW!h|`=e+6HO{C!xGCjJ!srqkZ0B}Q=$h;ZK4b^I)e)??ka+R2pZW*= zWrhd5j$><{E7p({_mZ-ZlF(au5jj2FnUgIzbb0z@b1n``tvm~oMTT?VaJ+Sg_zI}L zSYNd`b7zXHQQ{X1ASP zB+kt_Myp*&HWpUl4##!{W}EX_@6;Vd1d|5298PnP( z3U96rjlr~Ey5?wF^(vw$ohmE`K4?m7RYbw{ktB*#*y^5f{1Eo?0R;y{i&Uisl^oMz zj8B#61EgqJ)0Or5(&p|ltN?{2&rlA>=w50`BRajI(N!$?jiSei^WJDiD|LXN=m_6c z8sgu$8X*&P9a+Oa*N#jkC*;a4{<$*PoY(_w7g^&Qp^;kl+gZ-?a~*hG&I&@Z#b0=M zt;pu=5SoWi0Q9VuI<#Hm1|2W0)yyG8>YUs(+3hP@D`fIDKrA@kbF~f1tgpKZsA8P6*jOF zl@@T=kP z%DYM@gT>YRKzi}|Da_@?{oSUvkN)CVZf*aX1S?GBvqm|WTxMpoUf8W;MTcgpD~D !`9x2i{S}(M6(qc8R*sr$ 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 !}JZ1XE?^TQA08e zq%h{=G+Yn8lC2|=d*te-(nlfEhr-&y5u(z?v0&6kU1;}2$$rg&pNSG!OU;W*YNgX9 zZ6iLj@xm)1!mzt!z=_qIfiqxrm234I77NA@u?NT6$04!{ap!9wSY{0?+;9=DVk&Qp zrw@)^vc)#I>d5K;g&Q07-&U_1!})Wcm=JtX#g7SCA*Ko`ktReriO;F;6C#Jvugc^6 z{v~Tmx8SGu7}eEO|IKZVhR=*4ZbD!Oy*7vopp;aWgE!EAhF^0G6A`iMfi zrct^yiJBrq)vy&R)6pqoSrW|fWEt*DmLO+7Ky!d#K0uUl;PNGbODYLtD7T=wdH_}M z7TuVsa6p{B0+ix-l@+r|)N-#hLod{PQQeu>RE`-a1NgP?yYC^rE9a`OJHcT>A&V0_ z?L62W*ZMhhUQWIqPi^J*S+%CSO_X>4bZS1RWBLMifBP`HwL}B%Qc78q*r^1y%`vy5 z617#xUJ{|5OvE_T+T)8u+?t@q-IL7Lg``ECKH}PtpaRU;)OUth)iy!N2WQFm_urXn7ZXYR)Q5yL zo$z65o(i6bo}PVm!2k1uU+PMSKJlrfv$Cq|{p0izrk@rdg`2`bhPr|2D;NA|$)Cj;zEnV`ET zaAR4v0rvNqK8-lK8^3CC`8@~{0je^=Q-0!Q>sf$bH|ylFb{q91+97Kc+ae1oP_quV z7Avag`_3OdfdZKM)Y!-`45+>I*8W0kdTIyxV@RWcAsp}ldjA@5={miA|7ocIA>;Zs z)W64DKoSeWlLZOF;gdh~ejfa?8&AY_dj zJK36d-JBleVMvqUDIH@$ zrI{>q`LnE3%X!~+GGvnIRpNfdqvO6geo)GS(Se$o^GTF%kp07Q$koo#?1YxR#4R`R#Xn{5^m-m0P!RIoz&3=nG0Z)z zIUdfc6#IzhxVPhqWhJ7iR-QYZDo-moWCh)_!Es z2po{1hoiydLJ`icrDlcFsJnZ6(|viLruqGSd%^2xv&O@&ofaHbLDE^OFF5348&O!1 zH3uB4p&9{fbh&gB~NSco%DN|*xbC@;P=f>;&{T%gJ{Dh8R}$oQ9Ig=Yp- z%hN7+it-wUbXxR;5XIHxQKaV)YCLrZ5XICG#A^jQM&+)~AGyVo3et?Y>5`}zBm{mO zeSj?5?DOF7Bjb<39*giAl^^1+V68;83v}R8`X{5-^!pYS8$8$k&@KuEy)(T~)@ASx zVX{#*8?5#={l!H$m#elbH{)hDn|4?``EM>zAOpCf^Bb8KF#j8LO4>S`nEkWlj8T=f z-ZDn?+3~Z>E|%Q*AsMi!*tss-R1yL#i=9YTY%PI3SZa|4GN_TYO&hDzy(1-oOSu&< zPmenV6fdtSU@1KUG#LVN5FU?+d@!Cs3=!;}ckPb1n&7DJ#gpstxHJ9RXD9FTaN|MXYLsgOhW9hYrckbBUi-p3k=wRB`A2 z3k@qOKY4+4(+17%eFLN8QuX?KsBNRUoxWVwhK68K+OWAA7h_|o+W`nSGXG{o0`FXN zsfT3+L(O?;QR7PMjwKF}*h({PaP+6E7VFxuPe{nrg-VNcxoJ;#vu_43E`i2jJk7!% z2;GhuHK=(Vm*owus0%bVGHtpmC1D%ZZow1Ws*5$*COQK<0}{|f4=Cc*>KN+En!0*G zL;aK_w1x(M0x%4kn)#x+yu_mI6-gMQV~Ym6N*V1#sxaY>Ar69vskXak;CXFadJj6XGIzb=^1+1x>Qpo(_9y}R10hPE<8tPwPsz2pFDDVofI=uKZa zEE_jqtW~0pJR1>XI=Y~Bttr3;Mc^&T&f|#PPqZYr_}7gXf}<7)NnHfwZ>A{RL1AyjZu3H(!7c&p zhlJGhl)WBy0V;UApi6Q@`GfL)!J{IIq&LJQnf{|6r^rb@ zyqP`7Sw8k|vhKXCP+@n*@>~m)KG&us-&xx`LvAGT=Vy&XD_)ilXh{18fj8EKFFTtT ziFzTuJyxWf&WN;(Tn`fS&~NuX^uTjy{Yb&zfOm#SgeKS10Wx3AL3!Y4MMz?_L3O7N z5k|h)5zKALSajl3@Y}rMNzTqBTw1^^MuYOGYjV+u{#NV=MHjV@zV=T92brgc^<3A0 zP*JTHH~(&@BQLtCkF72Kc7KTOV*R@3eG9j`5{)Ac+6H|9sAwr>4rDm|*zC>eJiaQh z_Q+Vu>*|FD!8MnW$a90?Idid6Rtdp^Qg@VbM4wy&z&7=UxP{^=`oRrkefd;^RJ5m9 z%Pt%(KyUn6&G;V2r>|*;fXCqz)&d8HBf4Q>u7g~WAh(Qufb~c2%(->k6Fqn%2P-LL zEQAy1&24M;o;|{O`Es8S^8^@kM*sQipJ}y(KYd1zZHEX~uK^k}4exOB+Xd=;yTJc2xcc7#`X8;g|7y6zs7hOJDWmq}V#OJa zy|KZ`OC>dj08AI*Z3;>xA>R@b4H8ikOPduFvay&Czx4qRD}slShs^?l&k7B}gutLe z^30`2fG0!2gsKsdg@kAf#uC9QId0dx9kj)b8DE~Cc~5h_ZoTFn|6bSik`;!XWs70+ z7AS_Euu?4~L8q{4=8L*&Ebj4*R4Yw;N)?o$X{MHU8F;1|)Me@pIp!=qHX%!rMsS&G zm+j-k_F1mUDt+G1(eLE>KEJ3$97#_TD!6Vr()bA#I@`Ld6i!ELg|t;!bDkJF`OG}2 zMziAN?lfuv^#qW(!{=c2*|L&s=(+Z2E|h!J8lh6x+GL>-5Mhsml+FQ9)hgi#JJ${? z7F(6hEeYy&4p_Tfi|%T}J@xa`Cj2Vz%H4G==x3XX;5Z3r6vXjtKDAyA@6Jss@3~-0 z=sFe_SDvbHKj}RGX^~c6mVF^fRs=JsKi6isT)7^J;Y#D%idF=kTVcssj*d2|vh)J? zw9bqpn>B*Da^VN7@fcESP!z=NbPO{}T4as`sA+F@1%kuH;R{3RtbTOsKFDDgm~Xhk zNjb%cj`IGgPJX7eZN3~t+4^?Vc&h=BE$rR04<@?{6su{!#DJUA7R&|dxQ<=~a(?8TErp%Bq>&C(soZdz-+ zitXkdHg~xw!Q*iL?hp2x}&JIBfyJ*x)9EffRdkYA+Sw0W_!N&J+I z=b>f5qKrq`u+3LuWtH{;%ZuxdjA#RjnPxGxq_7F0_ORx`U~-fjqFgThH^ZEXg>>rW zSTEc4^T664cPs!4brH=^>BNT%7b&0FL$`yC2saV0fsQQY4e`J3i$Ug{Fg(Kl*xYtrex1sqL_?(ker?BqNBcU2OXa6+__HT0jO_uSs_6qyJV$!6HJ zGs(9?l12Chm*>v*=q28%7ypI^9sHJX5G5>>Kqy+h`gvY*cvo_Ub}l{$w=^oUMZ(#;`V|gaA`5E*d+I^N_n`s%rACCW$FguMGcO)WZx2seyMIgj z?vw3jr2LWqyDl~`3jcMLJCL=EeweTJH7DXLHsWp&ge-Ct z;t&PlQ(@F;Q}M;5G3+JR>!zbG&S`_+&+iks-oFI1a9o_wAXfYl8k!N+Aj@xA=#szNwIfI@O>kQ_fw+X~(gs_5#-Cae<67tos1L%o?kG zYe%AuFTEqtCw>BLppdDTsS4Ly{X$OKrrihi@0%{Iw;$10jVHCMCYEnbQXHxy4K7U! zH7iqe)a~>?n-p~}R9ZLYG^!0-t~y&wom!RK%7Oa|hyn=F7`5f^e;|NO!<$PEeDkF9 zC_11lEh9CVU{aadOZVHiCC4sj3_;Em8`qPyaIG8sl1+R^VqbA|9tta%T;~%$XD5?c z*hMPo3pp8?S4XIQihg68HW|4RO}%lVHC5f zBu;X*KyH_C<1mg<_2nKVbb7Oc%sC`82Rngk6L^TEbKR(VY4A9L0=Q(C1U0$qpCF5- zG2T4#K~;N;o^j+SZyy~9u<@)>CwF15tv_6k>!^04^Okg#u;DoB3*R&lLa-g-q8Xifiw#WelLNB41G1@I? zTnE`LwU<>pEQ!DopFZNEb^r>MQLJ4qYyAu3GDlY7CUlcRLGq4mN&NP5`(ZQpC=q~k zIt6tkEOF4mWCyuvBP{U(OL)%g$y1OphMVR~k!O}ga@UyLj|Gp2r2>DBBLd-4hNugQc7_Nrg_catRS`vOt@{~IL$7i;T(zc~pL z0ANAH&@cQ@6?<{8v?%F*8^fniM(jeUZ?-|-pY&5S8pGP`k)TXz;q~Lw4l%oiVSDWCfEd_3U6QeNdl&7RJ=CRyUfeA zEe1Twko88~E{o(1#oP$1edtY8&d~W<6RjHFPysS6gZanV6n#ue%~pyQyQ)FnQx(aC z`$8i}js4o=?Z5dum0GeFTBkFfb@3Enfsr3}nC8BLNote0Ts&wk%Ik7{>J@x(%XYUxKTeM`0?p?NPmu=g&ZSS&e z+qP}nwr$(Ct6rVceeQjIZrqO7FJk@pV*UHZ%E*~>jLeb0C*oax+urSQ!6QKQ(ni4J z)La2J^w@W^7vPTrCaQPaA?bS^(g}4^3z(NjgPqIFAmh{etjLCxW=)8=Y_SrP@{|hC z<-I>th(4*PE84|%^0lAf-vD&xt9#qe8x$|7&i~u}*x=}nee35tiv4`k|AxK!A-jI= z#{Wj8M#)J05QKx<4UWx~-f%#@3NnF@dem8pK=2U2d^Hl+rl`pYjIkDb!S_3$Hv*yc zmqM4CMqAM=)<@^>`-nYE|C>vd2)I8pt=w+3TVpwMZ8VCvI!^x4-gGgl6`~|b%iFeQ z&#Jmsby~JX0&ejSOk9jI2{XX6-XBms(pfO8*?D&New1sLj)qDtHm@6Q!pw>kuy~!+ z`U|Px#(1cx>a`lol%RhQsk>u9$1dlli`xnT^WW3RK>V;;vpzG!ybr!5*bs8C^gg9HY}kAz!_ zpj#s!aoZ6zpj_=d{_`Nv@?z{Z{2A}mz~35d`CD?hk_Br?T9Vbvq(9CEQLoYgE06*) zWB*b*|EUh_`2G6uA3(_opAaB=5|#yPE?AM%t~}uh&)KiCf-wJAoCdUUDgMPc|Mxik zpAx^}zi=9GG2X+WB>ZbgV!Y3!OzsB+AddSt>LJ}wli9+_(0chlU<$PtBN%05xE@Yt zxxasZgx-NMCXyDa^|h}XLBYjQe$`Qc0z>-6w7KOr*> zsyQk)!eubG6OCGJu<}Y1L;K9JGWH{jE1j+2r<}Jbzyh$_^0;?@dCmssxseK579)tH zbN9%);YI21{F{bRe>zzDFQERLBIGBa{sGkgEuseQrv`XdNLAI`n62~+@mGKnc>UNY zFPP6;{uxkH|B00QzafP#f(%2Bi2$*y3|9PTP|DMI$F9nxMY%e1Ie$o@%j(Q*a*BXh z)@HiY&}DAbgmTpkuge&%MbGKPO_E{28QMFA(9M<~Sp5dww`z|v;CT~nzS(y#04CSa zf~wy4+Pz?lA{pK24b^w5g)v1!tyd?$p3q7^>#psp-sl=()A9Pl%tQTyna4s>yEbCt zO~}@PGZH`@f$!KS=%1@$~=9QjR|~o}HAg z&41iuD^=Yckd{5at}d=7uFL`g{`xEe0`-Yr;Omap_{99e!`3E%6GnxTO&3xRWtyw1 zQ@^dzuR;6>sYPTF>vb{{pbL#-7TaeAdkx%Yl|EajJZB6|UyzC?KHYzCv~zQdif@za zb~k2h7wt=u`5fNrv_Ib3-hb!1_IPfd*7{uo^{ux94w!vkrM0k$70`1Hs=GJ(%UA~3 z7UuZy0`|ZLFQnL(E@XNi5+n$!A}L%ap+DL0Mc^Yg!;=jRS_gcu{6!y7=YBsG*Jw|M zaFr*qfBDcx45lBrB?6w!T^ZX;dMYa!N;{?=1=0qXW^|PWs^fxU@+nYFe`QS#2?W5JFm8t3SDe35PlBzZn3jm*3b|p?4+F-x* zqRQp^Z=XP(m+xO|_N_*;tyC%F7IQ>cVueu)`mJ(ia3n(nz)=oF4%pjo*|uhh9*XQ& zXI5Je-oHa#OB{P5dlK&ZrCEiRpx2@fMk5%rELZETff8@lwUik|~HPPo>EuiOI4vg{+@s;}Xm?=2No@ zZ?h!Xk#*KmuP%x12^}2{N}>zvs7`wonPXScuZzLztBM>uyd$(fLGczu9hXD{&Gga} zE`(t8sBXVpjOpDqd$v!dxtPNB%?KNW?f&ZPbl0~fgP2YaalpnG5Cj#I#3I+25#yJc zz}bWj6WX}H?*Rq_dyFco?4f=~uQc7u%KvPZUT>8D%S|Ev>3_grj=)X#x+cTGvBYu! z-zZAN!SJ(9hkQNbY>o1e@=QEJ1AL&pZRp6YLk54yQZX#Nws!w&EGVEIp++UG{Y3jq zaqk56`O3jazvDip2VZ2V*P_nZ^!cxNst80SWjs3Sg@l2!ghoh#;I*jl>i zqroUKukT)iQJKhJ2uw>E+M70BgR%9(1mFZ(31L8u0x=S%mn}MXF&?z_s~vp(pz%F0 zsZFVb(6pWU>UtLVY0_hS*nEaf5fZ|-z|ktfF6Td^EdHy4745G(K7HPUgb0#F(^HI# zs|TE9D&%M3&(Da}wL-qY*WNeiJKBw%EB!2F0?6*!VlPP5J_iK%p01sX7eL@3v}FTXrX zb0}uhaYvj)|CHZ^!V=mUk>=zdXOT8~PGw6yJX*`OGLaUyXEdnIw-oB;B`!%O!T4RC z_DUM-DaaEi&KR&&NN43Od-*hw&_1KLTjy;I3=FUj9Nfqumdjf2&`5p|ZPC_Z${|u5 zjOnDl0Bteea3Oj}ULz*n_NANjm?4_iEcL)je!y9$s)o8DM(;5Ldh73rywGV;I#UYM zx$SjMre^V_iZf%MOFpc7sji{P6wa-VxfE-bO;nr7k90HLnv$84STW2J1k2>6=34Ao zeq@Gf)Ckmlhbk5>4s7oi6LV9rd`t}Rj5v4uuLBhwgY&1jA)q0`?nwErF593Y@(j}) z+(@u}5PX`86=rKRt~FG|?21A3bdRS-;xIC*h_?y*?~>OB*%u@arJAWyhl!J#U(< zR@!UHFEWa2GDINWI2&Ie@DFYaFrS#fMQ4z zSs9m92HMj1X6wx&Z>2N&`Slk!)>26c?taxLt!$ri5W3`eKGI`ug)wNX8V(BOU4qjvdDk;Y2D@Q|>Cp%c;Gn^` zUhPTRVt|-;QkgWA+1~1I+shg8n7&qA}~noW}92zaN zu!E+SgC&jw2h&uF{Zp**{9>7$;`Rq+De^4ttc~F!(k*6nmx)|UyTG^&MA{C48#h8V zYwXqF`;kA=xEd!hKl6nqz~_WQOSo?!Y#~AkGu4=BOICZdmgxa`y%=}ew@yNy@Z&6g zaV6T=cj|6hA`7g+t&K_AIB2~Q!@01zFA3C?n|GNZX9D@w8p6_Tv;<(R5>?T*Ppo0L zK$)-hDZ#~Xy{>J?!1&LuWA8$Ry)YUvoW@ovzg}LH+iHZ#&6TikVwT7ge|Hq9Mr*v@ z$6BGbv(BUO-q)rx2<*y&%Vd?WJ3Pl!NmYhgH3i%_ExBgN=|kkA<+sa+sQqON5m&-;p* zravQ}(uLP$!lZ><)LWpTV+t@-eG4t2V|+_GtY(cy+l6WKdH%%^#fe~=oIbvu5@e+D zg?Y42>%UKwM<@9yOp7?pu-wH9rETz{(<|R0sHsgHR1KG|()zvb5VTw}cYdNLlh}tb zvgh7{xIGN+L^enLZb_uozHz=HH04Cm{&FKnGMZ4g8~f)jPG3`PM5N0-G0?$oJD1Yn zW;tk`?d_h@q1rsx9Sd@GAx%_D-GtlYTCWJTuoNIFQIkO~t+nV-_4HTt&@g8PzMCR8 zV;}rA?NJ2mSoWb3VE^K*jl+h=Vte|Av-^fRq1N7x!9;^t%IA7;Plf%&H|ss=4#2MH zD=q&a=urJT&ft_V%T66+%M;|x(VQ3C(C=j19r7WBxdA3z=tzBv2Ux!GD|23U-_-|L zU$tnAIhwep33X#d(Qaobl@gasb*N;Xs6XR6UbyHn7!|x4frmWNbGLj{{jOlS5EMJY z9w<6NRQvSe_xm0+jeaEoG7}=csy?TA5cUK7iecxnL}j&tltbe1z3R0<=Y#SMp>7S~ zh9_|2w!9U*&8mT3vpxiROjm!TURqScMF!YCge_!UoDc(HhPLqDf+M~dsOyY1ui5rp zqG7ww1-*YubIkH!J+sa71iKDIeTie*=5<2=BL0Yv=GhEUo)%{MvpT@rq`{*E-&zY{ z+qgVm@h$yyrc~e~eRJ$$f#GHBSc_b8>S0QuMYmc#{Aw2khLxgJROQ%NLaCs|4|3{` zCJ({WEkUwc=_|ql4S1wY`KlWL5*NIwE1@+jff$3>=sAEGuN^`c&XAj$3wt#H{&B54 zO?fDuWe1i{5?gM~2Tbfl(|hd+&hM2m2u#+s(TP>d#dZFGGWV+z(=?! z(K{vc;GILrp-Kw`QmCXH!Rn@imW?WT+A<5quawuo2}|l-Z6(@9r^ma`%+Po?V81o~msV=~ycFBmXI&zazq{*J zXG@%D{{6&WD1kq%$6f7m_KI0;9~-7ixuO-zpkK-u=7QeVBHGjCqoxODKbUNj`4VQ% z9p@OSd}&l^=7fSn;J$eZ&*hq{aOq~)xS#m+6>b0Rv_8B|1UbwnbNlIOMc`RJFY4T_ zLx9C}q5X!be2jid-iX9>fYaXAF;UHMAAMfeow{vU%?IBaP5YZmBG@Ym{KR$Q56uj% zN)2y^;IJ2(+$}`fK=TZ~_Mq}Dma^Y+jYLP3^sTV=@#baT;-%A;EerIe^ZX2T^SzZl z$MvN2ai`CN70$A&b9;$Xd*<_3M}Q(RprLPk%+nD`0ml9Nk7=jGl7=+3Dow7{!^jL9 zY`z6pS6rYJVm*IrI`WD5VV#%Ga=~5S^!;6*rkLDE2<=x2*U@?f36Jj8*U!+84vE(; zyAlZ$6^$c=4|=@h_Cb4{P#Q3i8);*qj5BFCKC3fxfB)q-Hig`v+G=XH8)#^MaQu zUCJ#k)6yqFM>GHw*<&Dy*1>fXH9_H7+P*<4PE)l0kOWFJ;Y%ywiJ6o12@1!paMFm8 z&}ws334%dqi9a4)U*;+zvBW#ej7X;16AK<-rtC+iAb-q$FPH+WR;8*|N(pdeb2K0f zG^VmvObQD_w#qeRpsuq_n?(g`UvOQHqz$js5SZib4^ZE< zhPf{At!!me9Bs+f)mc|&Pqa4*tBx1n?-UPlM}?APETKIw{vb4CT(+w~7~C zm925UG>8K=zLGBe`P-x%C|{YDvW%NYH3Y2=G~U3@Xd*G2x9Q`*M*mJ1pYw|n=ylROyO$#+KlZtJGmi3|+Vnmq z!tFKp9Dn`StM8a|37zKAf*!^Ig4#)gBk7Dft-w03c>0DLr$4^;&?`1-+6+=al@-L% zO^>mb@v90o^4;Jny|s!$%Z1k}a>;d~;S@iA9_k}EyfW^WX|A2yv@617Nh`(u|k^EB*MRSn13?q0}Ye1L(&BDzqQR% za{*3Si;yii4vk4+gUt_<7h;|f!tCCz^;n=Tja(Y39C9odx}lNRoD@x)aVr}4-7HD+ z)+$#@E``gRf_vLh+#5X|3O-L3t?~f}PdPztah@}l+HOmh{2A8p0(Z&yYm%=BwMu-F zKgbO|;>p|+?P_qpol9_^=arhuWESUor`lkgmU_3xzcmv5Cv($3vg~Rg*f-G*|0*%Q zKpg&E=E#|>U3z_i`TfrYDgOE?p-oZ{+ z-{Iff_m#91FqBZeU{>P;YrvAKm2-0RB>tq$i050Htflc|V33N7OO!WB)b%y#vczxF zUP=wymPw0?v)d363x@=6I#2?Z z4L_M;k_A6mPd{X6V31)5hD^y}nkXqkLtld=PFq2AmapeWVWQkmyzveJY-)OQlcKleeVkR;zsg=9yn{b*jcaaKT30JJ( z4|GO|`t)e=sp{g#C$7$xX(xtJ#I2r|ITwy*NiGwMWlB+gNYappcjP6DFiOXWnO&Ee zm*glfC~i-QUsNEeKtp_=W_jK~&~-@J#-azGp7eg*rLEfTZ8BctpE`dlXh87vml#oI z26z!z$0dkYCZ&vU+T^LkYtr^uF|f^6WL%pF^Ly_M1)4!+i?_`-?R>e!0K_(%$s%1` zT#0gaYbWDGETAkrfO698Nog4ukdaO+q$tbgEsVKX=su0@@>p7JF#==0=qMo!sL#DG zfxb|{81T`n-m6Tb7}G0u!pGy@U!+&%%Z(P ze$TT);88;BVbcOYfPu9v!1Y8!lSp&tsr@4>1DKH!ta?_nXxqwRu9O;GYR(P$@zLxW zKgA70$?Pw@FE9k~4Q(S{?F3DJ(D~0?E7g`0XBd|c2SN>$yJ>~&b>*Y%HlfFnPCPMV z?NW{xY^aw7xQEc#=1ZH0jBJJdd}n{Z>CN?uyN)0(!!5bT0o0>jWt6Nx4u8@S9xzaa z;%^R>-x|%}O;f>}B0O`oPpF#S|sl0v$PITYv!gl!EZu?rAC3dB7@~J9v3u6K3Eh$RA6SxeYeZkv zb{|~HE`E2>3bXH{a2W~inD3^9;L=^Fm8{`_3v@W3nTmGgFUAG)$FeV+Yp*CP{oR5A-hrs!K@M+!z`J~O zzqD3|AqtV5)D-yBEo|%j$^*&*B)>T1iSJkj1N;!nlJ{ZA3#JJ++wBUtcH>VilkF5= zt9bMBKNaYGa4thUB6c{aRYKNj2F_LX8vPJISnhhRQTM%fD7(+?6g#0jjUq+c5(~WvFbQND+Oop}&I8BL zWfX6e;aY-gG&YE(+dJa03-9xIqJ}qUfCw&h9VA{*{;O8ugo&ZF^V1hq^3xY3^gqeP zLRJoTuK!BJgg@E&pD+G{Y%Ww@|3^mt#;RMDnhT^}Zc5Or1RD*Cn^RVYEG$H_Xer}s zaM9{xrYvaJt?$jFiQ4ynJJG-zK8V8&Uxl)pV{~-q zEI+(=%i6t*Ff>L`A8L}MifyV>`}v0q*XeB8jF}qhUXIG+kBYxynQRAWp^X!Csohj# z)SKgKg+O#S)bWa=rcjHxRa)9B)*;vIl#gv|=G2|!>Y=-y0|B0s@C0wD+51=UULP*_ zW1O)Pi<<1(kBDKRxcSAR zU{kq?a-AF(Z7NW(3Ny=z|3YJvli|)Q%Xe5xv1@o>7u!UV)qsZ|7H4bHH7fHz5<8W* z=Hh?MbFWlZO@=JYk#=G279AsBG4-6=d7PC~00sO=ieNZNoDF6|(_$ssXUs~hjjD)f zrzKLQw_AzP-7kx{Z^6|Ms1}Y%-jOvrqm7e|p$n5jquBuvu!m*~(qHs#m7}erXrtQq z+{ho$JPfDe_Q2gI+K96SPiEVK8$9%8hWD4pQVq)O_iZ~A&ctsGWcLp4!<1U8HoQJ` zj^g98$)Bq{;dA`)6XA{0ELG43y=sopy>cq$^^(P5Qa*5INxj+vEdF!8zHOj3AF57W zoK68{{GAU@9;VkKzHMFj`Or>YFY6k?_ZF22n9Gx#LHq@|e$sHA5ANTWCC@5cq0fNU{rA8~!iWq7FoAxJ4bn94nnJwlbv z_LJdXJ5?>vM^&uhAkKrApfNd)!8E7CY&zZJh9|aI1?dYh-1T&8wgowFaK72%ih|Tg z*R4l}GQBL>B{4RD*cU=^a@n&Zy4G(scz(#(1geoAa%grXAZ!N&3|n2?c~Z}SjLr!7 z?qIR^ktleRWsE_jQJ?P2X)Q%BWJtFRm?%8XmYGjh$$l%LD7Jw$$bz(z1fcHCWyduM$9j z>$fB^#;vViIx{0Ts8Y|f5e7ymGG~mwU~q2;Bm4N1Z2*B8X2#G2ngWDh9R zVksR{_A=Hw+ucMwcAMR~uTKOGHxtOSYjeti9M3r+QTS0xDkIT`wii{Q`pv_9X!#Ig zZ%)J`Fvlp$`&O(`KWo|(_=3!F`-w!~K3-znH{}LGKX<-5IRL!8C3V*_jc+$&lIvuu~N!UGiN;?klGEEWHjnrK( z^}VHV*fX;zMu);r2+^Vo?W?aor<|ugr((Z8o}0ISWA-@zZrBm$(y9WfL0n$Bar?z` z6ZR_=ns}86@mDk%b7jpgV}0FkLE3(5^7Qu6BP;Nkj}&NJATA%wqm})2fIDatBT-_A zi8PcO^82P9<}KYN^9i?1tu45lBA;ef#;4OFTM|q1Ad4d?7(Ml6(R2f+0>}G^jO^UZ%!YD_MJ0wo zU2BKO^|fI(7k7IFh+t@evZ@FqBNF6&KhDxw$$4370`vX4+`3wZQ^NyROtr@7rLdMz z6MLeI%vSt|TP1xbEz}Fi!E)cuwz|J|H*BUGn3gzgWYgoJex+ui2#D${tVUz08jSm_ zRX7UuZ5Dr^>JYEmQ$*ag;~y>jN=VfPPb6zy45acyBo7sJr4>@;IEO3rV8{(D$o16S zFHKDHY1X7mFwsr0en*X~`+~XTU7E%LPO>5HhHVN>HxTNmBSf}U*lZuBH#b{2c%DTT zr8-A_Wwm0)8%n3!WxN=ZzBVbl96IqW-9>0v{=G~F#~nV{M_?ERa2u+%u$Af{EMza; z8!645I6At7inRdFW6;B5jT|*h$3SL*_{|nCclWyVDMns9yNDu@7?Vv@)duVb{UmuL zB`}pDbN(63RMw83Yc5qM=~yK<=v%AVJ3{(NP7!j1E^XT+F@Wa~;sS1o??gbpXPJR~ z6BXiYn=J7BhOnw`;eijc9}=Q}VsLUD>Vkt4@)85h(>ILI-CK;$t>2F%9rl8$W3!_4 z2g-F~Og%c5YJ$9NwK+!a2=zBiY(&L5TYX^Wd&Vk#`Hy!|R-@u1rzhDC1^g#e3l0ge zht%M19LMkN5Y|X*A%|VCU|A`2p@_YT5JHJrwu~PQd3A3e6Q+`e2{Wq7O}}#IW4?^r zP({?CkyfUhV6;qMsv4oJH`Y-_!7{fxU`8hYy=e5&O>Ts z0TZ}9JW5)jRCd_GdfKeC5XJLS!(Mt`iOOk$QM7HzoI@20r*oOyKx3hVsVP|&W%F{5 zc+-vbX?A#ATGnUBk5Bpj!4tWF4w+kP-P8fb@c|IMV1=e6UXSADLr?&gupMkk>FV*%$}==P#%)Tkp1|| zjvqQre5`6*YzX2>X-uqYkoR1#H?L>`9O0!PQ1h0^K0yF+TAFgrEo@TKzI0gApn{P3 z`N`8@Tp#`bzy}@UjTYGbX2=c6%-A#T)U$dAAx8HAg;L=r3~7# zK_N^(@Vk{^O?7nwP*CoO@C=m1h* zG|^NcQU}t3R!x^?x{(=Wjz)d!tLgx%>G)mPLB9k(0$&URYdY*882;9fYQIXg+5eL< zd}>6a-`A!y6rNPqQILk=06V+&hr9&tw7-YDD@$9R#bz}8``@~-Mkbo-w|2r6 z=dLhC^PZ?{b6^}Osa68!%D&~$i0jNGlX>z&e#OBWfJmAYqrDZ*pYqIDe~!_5mQZ-&8ygrG; za_Ud(JhL2m${^Z&<0AXU0urmQ5za%xA^1Vl2zn$Ki`x0eT;MqhV^#q96F~NQ5oi4k zn2d*t7raOCp=g5>(P6McXExV(vt@6KmsMlkC(v&pg-+L>ZM*74KUIG45&!6|OWCx`n$2hJtdz5T)s#f6h zmP%}GI|cA(3JyTB2Xs;WgzC|r=NnI7!0bz4G8!~Mmfdg=FCRI;epEUeL07M&jYU4| zonV)#p6DBWK%QRv3K>A2K{>$S8zMlS{(BH@*(k3lc&u*P8;Osxp6XuemAY6Bz~{ef zJ@nd)Hy9lS`^_L;#Ru2WAHQiZT!6h9Z%8`E;@0d0^zjy@z#&WJbO0*T=LVos1O1ea zs(W{K{%~-NYqlw?>8>dEQ|g@h9cDJD#OlSeY|OW2mk{&3wnO1bvN*?2 z#}Ui-*{Qu>q=;*D2pa!L+7!fq2#H@ zHNxFv6Z5^rEmTJrek{x3NGjyvr@?04npacE0j<*8*Qr~*6Sx&Xsw1?BLUA$X5LLx! z%{|2QIzRi|UK`BK1dvqto-Sm+P{^<^F-{gRU2cDQUZ}??yUio(%_D0z99H&58A|4sQ zq9C&=yTp3zEV7wNI2^oE8{iD=BW?`+kprv*@(H6r6XeNcw&*w2w1uvS7iUmK#$adI z#fuV*z_YsCVZ=skeHC(S&pSiRHc7^lM`lduPVL-E;neXD=vx%L{A7k}Trcs>*=J@1 zfO1;mdhg*X%H;J0yLWnrNMN{5O^Ip?0w1lAQ5cJ4mK+JEx4(0~@8U!Uv_b2xuTF8C zQTiQS;SJcsnNUVpW>sbEO$6xgs9fyQCnGpYgd2hJx@aH%%46Q%529|!9K`kICTc_4 zVM|cK%wN|Y80~qg+V08sPM0HNYu)WjvDafAX&J?z9_58Lg5$Ph!;`MtjRh z-zelB^Z|-P1angcOvN(;ZA0jQjw9&a4HV_Kqf>o;JXf`uLo&o=x^ z#m5M^F@)24iN3?4ls0bOg811L6YcaB#v;YXUMbLRh}%r3J$5aQ)NfjNp6PMMA=qC{ z*i~%xTU?Q~uK%)pOTSJC!B28nt}qWZdnq$^`fez9Ub(Ok`Km zdjEOe;~t9F({IVH2fJPg1|^>;rg&@pF@65$^N2|}yFj0>|4d?XG@=-?`4-&4H8Si^ zr9ZJOpvyhfM?#8BfPv6^)SLy@N(N64ganP1J=ov%LEc8j@kvj;W7JUR00GsRICu+o zWfJBI@n1=w#|f+Zt)pI|X3Ng6c;lLD-yg)aawQ6@f}RqszCE!CErH2dgm$9QQp5u4 znZ0j)FO%E!&T@J0)ADLn9-9m~6;r@S3$p=W_qOK|^&x2=%(`;gQ)gz^KNXSmOF)1L zX@~$DDk_iJ$VhWl-MT_~$P`(m103}zQr6Z{vxw!gs^33X#8xq1@M}R* z=A!kzAOxdMXcYUIg&!tPhu$C^i|3{V`NOhzU*G73N1&u|WUYwff%0}B$qOu^S96^8c5iPT|O_QKDwB9))p$YLAu>qK6zS$1jZt#pq|?od?-6#xp0G^ z$g>fI*4?Gp$q2#NJ$Y5&yJJQ!mkg;;cQ>b6p=o#C4$FTH%iy-LfN;QHzoNnZ+r?V{ zXC?O&mjAChZrXZ57}c}h+;|y70KsH~N@{&3sE!9WT~>VF3alWPah>u2E{u6cjeXGNIXw7)~`wOK< z%>tb@!X8<2rye5d#uZ#gF(M$ z>#4)PYXCz@?U$n_EH*%E0{)ab>n7C`u=tTe%^NmWd^vQC5$cT>ZdMKWHf_uwb#IQp zEhoFhrVzE3?W?Y~PT6{yR?ivi3(nW;ytP28!sZK#MrzT?tl46F_C(!m!AsTsd!Dbm z0C2QFB%6V5XOsyqv5xd}S}v1aRe{E=mQD)QKYvzndIc1MIx0eLf^KNnDqqLMUAo6Q zaFwxYoo^*Q8QXY+*jwN+ttV|iIgj!#&k9DY9^!2S1m#G#M5qAx>^{leY%IS9K>mi6p zInv=LYBl!XE_-O@=zGzfF5DBkyULM#Lc<>AgXWyU01>*@}K4^*A{ zB9^)BSEEbneG5=WL5&Ug~wCXsdFE0*mOA)4Tu>5}D~XRRe^iI^m*(R%|7vkgU~ zM?Vicx=tCnJ!gKFHRB#TQJXov;$40#F~O$1FD3eYLm9Gc1AFgjTog$kv z4Eg>`rX5C{3q^RuJ(mAxJnOJ=>pcm$fjLVu$Sa#duf9PgwuhrZvPTTr_?7@V3QR*7TZSf*Ba z)}_9vne2#E5iX9rwcl{@mLq<&Zy_=2`xbiWjV)X{s+1MUKz3#pR>tyVb24jA{%B|O z#?8ugs3DpD2L5eA`c6gz_kvW?_cO=JA^FZ-r2TIbmV1jc0}4ON3iOZ4&HX<)bd+^1 z91R7mEi8Uo`Tv*mVWzT%0;Uksms_)QuvU=GYz1LO?}(o}{GU)ggVvCNku+$*-o=4) zT1Hx1hWND9!iDS|9^6Eh%7TWwn1Tsm{Y2|7)xv2rHT6UP>aX9(GSiYtTD*XqGsW*2 z+}p2j=M0@5&(odOzc?eG^-cyHFtuFpqR=wrZ}c!Riwob0*wPcP@-VfN`q9`D_K>(J z^6l+XtOwaT@QtgC$#SH%O-XPOFX&v~?P!=vBFyimimN$p><35lJkQ8%{DG zu-n*)MLD?_7@zGx>AxdcQzVa&q)B+Xyn3~k`kSl*Z8q(gy}dW|3OumyGnvr@{mI_~ z)jyr+t@bj*8Ew~Lb&iNWsn~TW5^Zo8cVOx#jD;7p>GfvR}Z6y|Jjp%pRbZ#N_3hxh9JMqBV4CYfj2Mvdtv8x;Kf$~vN47f4W| zw07lexN1#hC}n>%09v)I+8{$`y33?=4d^Dwjn|hODc7xVgVedF^*{la7h3?*Pq0kxDr{BVwOefg=%n`TWJ7-auFImpAtpK|7f%i1~IA zStPoj57B%y{F69gs9eK<-SW&o40ZGf`%`P|@RX%ixY>n+#R0SJa?VX!OKrCZFgFkSzrP5001S@84d2 zU;Qgs8C^TSJet(PmoywLx-Gkc`@C23v8VS8eB9FQ*j9aS1e-t{t!jdrpfN{dxgL<$ z1Xfl);*YRA_TG+gMll|>SwRAec<=|j^V)d!;l6>nK2#p=wqy3X-8t*H?LIRAU10PT zSp+E|P)W*Xx}Z+stxn>7eF|~Ti&VS4hq`lRWs2jm<`1&LUSvSa1PR~M*AKepa77G) zF=KONSxq{{Bwe3eF^Sg?!5RF6Pxr40-7z!&eIUF-Kyy0!r$%P`p_cwfD#kz4)xU(` z|E!YZwPX)4UQ)=T(j+uGE#B8yFEc^!}(#|VwZYjXGiHBBzI!# zh#d`L6_yh2q$$jW)uQ!NB6qeNnJP+$frEJjJeFqZCA$d`>X?BjtF0R5{q9RLu~Q*wP2&<|#NQ=#1}rY1<6NFarlVRW+fP+fA#eMz z3n9XTfXPDlryp}zVZxsBFK3W3X84FbrEbLjpCLA3TmOBSEBXnos#GXQEJzKBL<=@D zrFY)j<)+h!Q@wZQp=K&$iVM-U`4dGR-L$!9g?fdDi#iln-s{t{foH94c@A2s=+yal zIJt-QpTg0DiTA=+~Ko%$i^-=NC z%RQO49g)SE%A&lb^X~>D2^=zU-%3M2%ZFedZ`s`obcqP(9$AxX?ubH5&~$pFXQYfM z-Ce?#l*-nu1si#eZ$|%k&<~I#Ek2g*C!d3x57F&iQox5b{>g9(!x+5$vjOjx2D?ob zRppU>@z6iMBWfG{1-~)uzxEQt4w)xd;;jZHhbpa49_IaTRkxPm1~TriU-&Y=e*HHF zy#Ghl{U4!S>Hf3GaIx`O{Wv3)Ar;EC_ZJ>G5EvY>jCMZ-5I-1#C>X#UlA$Q^Xw0Z& zh9n$c41QOQx<$r*Q^6fOGyk~isx!0KXg$m@b=4+euZpBZ@Ovpccr!d&g7mpg8p z2D}bUGO=IT@e^I`G__;7R7SaH)TCUa>}z9H+w()O`og@wjHjK(iU|wFbxPv_|tG}+!yga&(5TbFdWMloCguZ&BG_+Km$i#vZAKf=O>FlD?Zs$8}E*4?{kklEMnzbtic{ zZvL?}UWpNu%di+Y%lkFthmkIS(0uGMqd5jok-dte#Xtfo!>%Mz)&mOj1R8d!+<9|> zS;MZWB{v-rK0hJRmp(q{DqKTyiFfgu=2YQKW*06f%#wQNkpA%~nC=1Bp`GDNB2e%Y zhJjcrtxIHISzL9oU&u?+S|Y_~Hi+@L)Npsz7iQZ>(G`!DkaO`B>;T*?Qz+m!ov*Ut zO(0;B(>cS%@FGKyZAJMis;e_by<;d#)X3_^_k;jle;cd&mr+Bs{d4Zir9P%+NpX^p zV6^3~(&nztRWYhyoMpF9{jbeSh5;7(N*nh?uZlp~&DS_oq1#B7(VB?Q%q{Ydjvf>+ z`g2QY;LZrOW9E^c9!akXn{L-D46c|fRD4cnny`jaV+*rd{IQvW+xev$8e*QCU-F@2 ziN1_}+YP4pm?G*XHb;!KTQ1)FY~UkD~F&8(fI*on~j%%2^bVy%2- zcHk;Aly1(;fXa{2&4!Oy4Ny%DOMU@xFN?tRRpdU#G`WE3cGV0HIv77X&eH;cR7!VZT0e`ZpLF1&dA?(W z9gwUUjp44Jz0`!B$`+ItuvA)p#xYMB$Gy+q6v%|@U7!a*X`M_$6vpw>S=S-b^>KWR zZnC?giepo=mc2TIu;7`ZDojeN(erOo)iJgKyf-}BW)~-vh$>s6sPMw)| z@~sjpORz7a8asPn=xY_MmI*p(kL(fA9>zCRlj6@K5!Is8FevQ1L(M1;i@=3Jf^KS4 z(qAMscm=AP9PxRV5UqvDa=#1~jc7s{L+SdG$5AXq^p&E-o=u?fR|gmr>yZLJP0o}B zaoXvi)d%JI5vioH9Mn=}V$I&9nF!`^=FOaC4=HGOf8II{?9{jUwLk<2l4Y*L)xAU2 zwNSuWAmsk-9h4M=;XOn}))iFwR?_OiCGt6)RnD%R!1xSZybEoCc_1c2&FQWg!Sr09 z^p|E>Wb`ys$S16!z8`y?_V4BO98^w)7o}S&>XTl03d8ptID?zA}w*&+GkzCj9Pd>A3Y@@l%o0r+LCr|c3d-+|2}~? ztd&F8x8bV+h9&+M>WYjqW9TzgQ8=HGP*Z1&yDuBw^7`10K+;fX;blW*2y#anxX5Rw z=SxBWXBP3|nfbNymLLvPQ=tscgBZ`XvAtExztAt;rD>ehMs1&4ZdFJtGr^)>%>3%_ zC4L`Kz@l_;1|6HI)o~SB5Wy8{>ZnPS!kogyuI3w~W}-D3QNzf7rKXvZ;o(cDGv@e) zj`5k934C~XC{R&5LX?PI550g3kJXhX;#C;qTQW!s0M@GUh5XfFA7;xS@Ny3| z%7t$y^~!Hu6v0;;COBtEP!7a^+E2zqkOqL39ita^oU4QWb#|}yz-ZlONc@@7{e9{W z81CGCXDt_`=++!a6Rc6ujP@v*wj0*088I!+P?^(;TRB$YhiiQR6ffAWL%-l1c$BC? zTXyctJ_XgCK24Vm;BR1_e1xe$E}Mx!0=3LwO&4_RVqVKw!FZFOD-%8y5)1!qT4v-I z3;}nv=|dp@t_gSl7W`zhRnzRn4OAimAxySSuQ}&hx`zv-*Oi~noy+k5!`VH?*cN?j zgFod{JZ0P1W&4zE+qP}nwr$(CdCInpuK&H=o%BsQZ@-<4tgK}3&vRytIiBCV1z^2t z(0GF9IPIDW?|^6K?mN(U;_BoIE(Fo`f6{nD=HxRoiiw~1r`%GcbKq$QtZ3EZRhL}2 zgpT2Y*rh;M2Y4a7)3DeOE%~9|mTZ++qq1^aD`KW{D3F?s>hBr||G$*YjRMz3qM0L~0T3QKL0sa!(c?wbKoGGG=F&y+Cp9PoalzAGPn zWkxT&_}=C%Yj2J$+JcYl4rtx~qfIy^d#Qs_o&l zx_V!685OOsuM`&=qkvS!-b)eOW$RF-s#^LJgZKy&3e)Vz_LH^2%)vl1?j$ucL!bl# zM))4L9TnBe?2eA!VOGi_yln`}2+ZPb*xIdwhE4!vh{eMxGxl?)aMh70q>Qu`t+Kj+ z5?d4PGhj-{6)NlvJrNQR*wz2+6vM-y*NwLz^D8q22dK)=)N}ev3#I*m)Ie>gvi5$N z6ms&EWwKP%nOHf`BrHc=innTEz~0#Ed%K=wU%) z_#P>u!L>Nax!)>O5ElO;BBs3$O85Vo1}-@K=ze=ziR+Qk+>|gF^?R4Td~aSygQ+H9 zNyxeb2Q{7Da5{JV;0`L|Qwx@F^xNojoh5)KM+;I!hb8#E-~{oD+!lqqL@=tlfsGS+ zrhW1r&Te`yP;OI!LG05x;@sji=1$yB$}QOQ3+1gKQ)mk>mv@}#;8UvBx7sFHq7Bf2s%b76-|%!P7ud}c7iT-1-`MyVastTAw7$N85X3JT*ZrdG#^WoJjg zG*|!16oPuMu)(iFS9_?t#)a5)wqA4FUQBx55mRyqQ9qkdpqKEd!cZz)#U_|^eT)Zb zhgn`(XwIw@59xr49T=E<_ZKe1 zF3UzMIAr!OVB=CW4vv5kF zj?|~)j1^3caf})?Ce51DmTl~e-TI@<@fYcwsBPc&yE4crnY$+8m-kI3Ax zW=v{4CU+kvk_ihhmiuM%Ytsou4f7z@4(*O5Praily2w%-ENf$i+W1aP@}U!H2!nl^ zd-6c^wW%+xF{>?+FKGKBRhfp=n^G#^y!zKyu|HMW8B(2pLygo)$#Jh}W$3XXR~D|t z)hPsHwAybB_t?}*7VJc5YlCQKCPNz9;SjsmP0^%b8Q#Fis4c2^4HUuUf#>E-QA2fV z$%r(>%_I8gOpH=O63$64YNz-&b&rO~@kI-h)884?u?mYR>Chat%>-b-@HQ&Nc!-N= zKwd3WxeIcW%PvS%HhM6s-^wk-P4{NYJMb~f-vAJ60IQ+`so?NJJ zLhEE%vT)h>*BnAXrs1$5(d8bk!3zv$#m8ERU2E|C8e?zZ@GP4N>Y5_hEuzv>K)~xO z`NGZpO_Vqgf=tBYuja^$_eGePE#~kf8|j`%7&2`x`iK_$hV7(D2iq+LR~4J7Ul*ym ze+nG&X#dwCyF|GiE{5QYF8qst8S@hZ)_+zCl=-MLCeZE%m*7|BLE14wq#I~~5v6eN zH^kZtqeL$r0SdMr|Cq`)ff9;&8fjuPC0l=fE=Z!o$2*O1YB{Syh7xH}CT`xe*(f(c z4DA%bYk0C~(Q3Feax}&+>Vzoben`cOM<1jd~FtP!u?92d5$27h#inAwf z*L9{ngtPI^E!wEjLb)Te{_ti?ER8wsgXRX5$4<)(4KgYYxB)hX(k%<&mi-eToPX^b z-76I?IX*qDCx8R09jP&g671ly%|=t$XQvV-R~C8Dg=Xu$rda;Vg4_jr_N^>L#t(UY zjsc4Sdxj6D(cV)!M3cX`(}7}aSjD@Vs=oJn2+I82%6%M~Fe&?ptHI3hy+yTHDSb|= zWWUT zI%p|5r4;ftY@PFlocBf|HmGD|N~Z5`T8!SM{B_9{=7es0YRdvwM}NX0qQETY5q!V} zJ(E`Y&nCawq_lKNLpDQA^T0VX2$FKwP+!0n$IsF_zyc;S9i6nr8#5NZUf&Zyi%?7T zyOs*FwhA;g=GTU>FEgU<6jOvUuq7v8fW@>IUo)6sHB#@!0HRS3lz&wy_cGC!y1;XU zj!H_7zeR+<1tL2H4b(9UvE3O`D92reiJ9yL1bEQ0awG5k38b^T} zWO2ky%%{ok2^N`ewkZzplZ4+Lh2Ncp|Aoot3Bl({#^;H~=lSRL!0RC4PcOJ9e0A>0 z-bl#rJ&_$sPvq*6ksW*Yl6EeRlof9dYs@_}F3!lGc@x9u1@$H)Bos_k-rzE~A z4i;@9x~mOzb_U9QW~mSPx`9%3{n=I~!Y4x3Ss1&v7Hi0cVTcrwX;YWA^8J3+AsXA~ zPL4S~GgWoa=WYLXDD6rPvV+D3;mEk1aD&S>^a|ucPYT>@7ho>s~Xv)*;0|F z(aD(2E~Se3Rof+T%*C%4Zu+1XCrr}%EZS&YcI+=dJEm?qb))Qvr$W2Rm2n2 zq{Gl3XiM0qp^@yci6HU(F~Aq1>8Kh0vC*}rja=cx=~oU$V#FpbZrasYn&a!a6fup& zh6rJ^6w{f6(wV@HO?U~y>L_WY%Cn8jts}n_=->8@4LJl6*{5+Mg^D|g z8$VWnlYWa1NDU*T=tJ^ZgP<`j3-%%qt%{>dLsjT1FxgVFh^jb_lKNnl6!sH`Hx7-{ zrIs1?5|TilB_hn`M*2@A(br0i1?9#=AduiWQzGrS7yYu9Fa8a!Z9S>1ev{j{!I?^3!32{1fkZ3M+|@HT`S-wNE^4*sB3HZ~Re2*jk9Z7(h)F zpe6`VlLV9zBm+p2HTeN*!T>csKp9yw6TE~nk^~J=a%F(B5y*u+OP{t;L=ety3%K0Rwah-5+qqa(qV2P$b;tI{a<)4#AvVw{@0|G;2 z{h++0fK+ZiWV1U=$G)OxUp*k`Ri%1XqgVgs4()9X6Qm(Y+6YUKrDn+IB~Bv}H1Ed% zPaTaqqv}jZS@r;QND0ghTqaItNGXS228pd(f3Lh8P5OWL}E$PjR|HZU45_!j70T zMwyJB1i1pxEMCWUvtnrU&JKba$-+8(97cm4XpIQE#sGyN0)WEfVW`tvM=|{QicL27 zOHh6OsL%SQVHRC3emWk(?svM^E214`+#t=v4cS~SxWjQIIvsZLZV#AbN|}DjL(obE z>3-ouGgD=04f8ACOvk^=n=0e!9to9gE92=M+RK~FKMj!+1qX=25^%$*E;C!^=gHRe zca@vwFyoZAw3Hc%?SR;U;bBJE!6)PM96toyq)8X~bTi^I$nl6=D%ymw?mq^JD&(D? zv-ST{woN){x9hnJfTIgSu0>J!nKXn-XF-Noi|&&ztah6jW$hh;M673Wg6CJ^95FQn z+(7CRS;N-Gv(+H&_mz90Kudui09TsN?X{{OtT*w`$c+*FnJT zsnIuxld7i_>=LA)9MgLc$P=CC9W&pg#z_Fwf=+?6PH4u&ZC@2P8SrL1I^eB9Y@Juq~YNMYY(Qb^t z#`Cp%5I7?{udkQ>y#>e`TC$*`XGBG7()2QLUkF-5ka(T{IXNDx-sh~N26k_5^N7lF_TXV=c`yp-TKt)U(2rnk;n?QJA-=^#I(y3pg;= zOQ#n`lTPSBSlWi2QcFYW1-BT+@}h6;krsFo^ZKD@%aOqjGkgKKtnKnmBAG!p4dxj` zQ4_w!{9z2dCI3AQ^rS7C7U!k1tcgZuexet8WCyWhQEW|dgEhR)L7HI%#N_x1ykZNJ z>!@lHbi_~@j&$(bs6V2)w?TYyudUuk)*aukqLk?3@`|HtH2DcE=>?v3rq+Fn)7tpT z#7A}YqIblPXuFDA>d=Z}b4Co~@)^Xm|NI`H?G5F_DA2b(6}bxq1r|Y$Hc`%T3jiGT zRh*mFsoenBEcR)t5qKU{&VM8*@hShXMCC+z*Tk2 zXA6j5kYKnw{cHV>Ie1x6vHw?PBtU`MclRd~T_o)Xyab}KL|CdAkta+Y1m3h6U#zJo zZOvBI=o9iS)Q;B6^&<1KZAWo|augV){5|rptC!2s<7#)a-Uy zu41xM625uqicYipP`sG2*L({;6}g8f?lawA1U2bk%&8M>Nw3QF%!y8-D&)`{ z#8QzqsOrqzRBna8#2w>8d1V0C32C#?I=Ewz+V)SA+uwhrm0b~&b7IY(5Y&0ntzrDV zCI?TMZIi)1;goIJ^>H&o=xS2RU!tHG47o7mA-g?8cju%aIR&N_vOAl4;E4?7hf%%^ z(9IFH1_6h*7@h>cihxFJ7CRx3+@NHY|U{#X)Ye)W+6)((yL-@b- z2VB*uwTtvm4JtU(z_A(!{nXHyhBN1K#ehID&elcvNI6b?ov!fOlfX8|9@#GSRTm7{ zY?maK$0*SLNVzCusg=bQ=603M8 z^{C1P)Nu~0=*oq0qb!!8_;xHo%XkaTgvteTfY=An zxwG!pkR^mWV8bu1t@E8VUFV2d_SSF>!;`AcRlY}H*#}sD>6*XT9makUiB6jvQem+q zSMd|qbqTjrc}5o9I~eedZK<3SLVfnE*YPGWVQeK!2%q>HRH&&Uv|_>d_JEP~a9ClK zj^(g87AH!oO@4l4HSvDlXSjHikpBeDzG1nSki719x+?m-d&?dv11h_nhTW~M z+V!P%+p!{j>!Y8f^3E$6?`lxmj=j)?Huq!Vr}k_Wx9sr67xT0}73G5X;qMPe2d7?SVN|WjXOh zU&dwp3UU9|fP(N@wB zSLDOa&CUFlm?i*z=L}&MO@mH;gHF(k+x0(4($tF?2IfQH{kQkF{NgcLShuo*fJ2dPCRMQ=;;eR*xYMMZuh z6T}8aYQ40qC0D-u*h#Yf$r|yxoIC8}aH2hPUA$cb+vyZL-0bQLz%tWOn$QtCg@@?8 z{2FQZnF+hsRg=_mX$ssOl8qYL(W z^(?62O?Grz6CspVz;-5tx5kK;v!nycR#2c#Wwi=a!9UBw=3gu8rQ$xEb;nkX3<8C2 z*hG08RElk7b&{BfM4Pl%fh1&c_T@B+ZLV-I&dJ1U+_4r9$pQ=8lF$PvrK}ab<{b^( zi+*~4o1r7?_NdNYo8hl58N1;ZGC}n25zxulzDX(;m+2@roxz;FqcHSstZf6iFNxH_ zF}&zE7|lu1pl=9#q|<=nfa_=yZ<5YRb9U_wAT0Ut>dVJ<@lBSrPn=yD462BK&8PPd zmj9|SB5I=Mq+K}ealu@oH=ascy+KLmABkdBG83w5D8}qIuuAc&3G4tBeO47GJU-;X zNA{!n6YPqPlVBw*G4NS`2AYBbPY6>>l@Rim1n-LIBsxGTo77kHm-<+$aMc^Z`5jRN znqv|OJ@-R&(|!Ul zL`8L251EX%Zk1;!8JX+g5fdikZHDQ*CE;zJ#Y2ZqvYJaAM<$AW8EjkFc4cb!93C!X zEyNckh-3OeO${=7R#*A)lUTOE#9wGWF zdskP#kfp)k2MxTVyD@v=yGaXbCiedTzkqjR^zOeT2k|z}l1FSOk01ekAbhC`%Yf_d zIQ|-7Gte6hDFIIPD+#(_ymMV zC_&Y}-Q3Im0`I~q08-qicl&7L(oPsT=lKZg{FcY%jUCY$+lLL>DNdg9 zNXOj3%uwfWCND(|>MT~Q=f#mKZV^TTsl%3kq5wrKGgWbDWXw9-uQtYwB-=lAWy)i< zGYjD7)2Zb3CSIyG z4$qUax(i|eO8Y99cvdDGP^!2!Us*(JYikjX8|pl~5Q5^FbwyXwsUP6Ya!wYdH}t;p zjBDGiC9vOEQjqm7wi-uTLYA!jJ4r@RS%L7ze}cF+qigQ#6Dr%ap2|7&I-nWHfxIRf z)cwgFA;UrHwD;F*AlYsMAJ4m~^#~GxJs+*i+(f66HCd9Cw1WnX9lBkAU-@IMy1K58 zb)Bl!4l8L-e`3|n#Yk&X>vn@GO3RT^hrxN^$Lv+yeltDh2?C3*1UYrhFZRGMt0Ly# z02hDy^Dz9T94@A)8M#wQKAADjE}jue;xTV{P$DX)&b(G2OCQwGETQVEkmpXxu>LMI zs|odUrPEiG{<2t<_f+cCpvrJF=c?$3tr|{YTSpjEoI<7t2U4ABjx*g|Er&vvqX=Op z+I6_myP2OShUkcTJJ$1)1(qg97-#~;VjQAZdREy}iT~D#AIR-we*Y##CfA?dU-XBcgh?sIk~qYQ-CM5neAFQVYN5FHX!$VcIvh*cR|~>9a@ui00bSxx!r$6K zqk*&*5PM-X?(mGv4W$9j3*Du*^b;D6!5e6oB?gDiLx}WyRw5@%I8t+8s>6hB5ATza z{Ts)gr>fU}Q5=WhhOJ9u#fOhrDw0g91BPn^v)Py@=aI}KBqNjQObyiW29CQj@vtZ~ z95YW;_nTq@gIP7=ql&YAz6Z&VAshw}mN}VA z7*eDPr}L&IfF$D-E`&S005+O0 zmM_ovTS+!r`0cM4e4v&1R|6jTdmd1XGy9x;AJ{#yBR-@1UhV2mWj}UhDA4YM1Q+rk zn%#G5GG3ZC@=?wRsnperIifC(UR0=y&_dmErFJjC1~p}BUSC16KEI^1NC-+*5B0X` zwo%GVnRR0NXf@AKqdX@TH?pb7I`q-%^s1G>2!d}SRjcVF%F9dc*0_N)TU6A4qm6H6 zer!CBhm+f3S^G%O=HkuIG@n-ioz%GMHtiu3=6tZ}=5hVYw%dIa=kPG$fg^!#S6L<} zD}3tCDc*mahee0}Dvc8<1nb>MDRwJ&qAI0=K98xR(@dWqQ-Tu;nydl~ug-^MVpwr3 z%I^W;{qwWVv4SRx+&}=!(8o*<)m(05ttbpiAfOkrT%fI)xy#;p? z!HmQ2Zr{#@(c_o3%?0vOPed>yqSWEn%lqn%ccx+!P|ZM1o($dmO#W&C+%;7BrnC=^ zkbFRXZWD5iU%#dwOVuC)rKFxFiF&JcNs!H)FQz+j_+jiYu;y4zHULFK6Xo14sX(7d zW{mYu&?E0v`0-K%CzHl|?TB8-X(md>CRAg`L88R;bJc%QzSVxkS)$f&tRry}(s7$f zG;K|A>@})K7q0Fh^(Ss*v-j-}$}*JME?jLh(sG>@bxTgB8JgL#oNyD^{%J&pQ-Jzs z!?>x8zbrEZ9a0T+_A9@IlquEIuoc0=Kwrv~D*ug&d_gJHs_urlPN!=%ZI#EmfCe=w zn++n>n>#PP;<5$Dhho$xD@Wy?pmz$SvY3{|qTFq1TEIqiqdak6L8+FR@d^%$ociUbtfH%ZESC=Llyx}M1!Jk*_>c>A(-57AT=XS_SSGlaI zD-5rrdF9S)+UvuSOpMs0x;+>|p7uz=r=UcWL^HAjCSel}jT35sq5DZPT13B;(7B0+ zrfb9?mD0@$(H&;&!Shx~-rSXLzl~b~s~oLKNyX)+8Len9!$ysbk%*1PBFQ^(Qwg`R zIt`6+!foz#c^>=iV(P;Zn9Gmu@a*`yMXl*Ef(0RSogxMoo_;ZVc*KuCaF{+p z9Jli`k;u)}ZZo;&wzxCf|PMA>Z!5WdZZFHQ|JAGY$FQe=7FO|&R_%6p-g(Grr{>0V!yI^hYMcR<8;B(y{ zZ$|a6R3^mYo}FdVbIULDYd5~EUh6j-pv6M0t!<(X&+44ofp>#^cFVKgEPbYwx3=3m z+gv7fv_$G%U5!;32=twXVTjhiC;0GJ_SCR%8t-bD*BM=B=S3ZX&s_0cC8OWv?Bt3L z2y*wb#YYC+>b^shFOTI=QstOa<=~g*6wakas|Cpg8cPIaGy?=pz^oNXFPZ8=9!ut2 zh08ls=2^nc8FuXbo)dzxn`$x%&Q7A)M3`$%g9MQULKbwX0NI(K+ zHB3V>+=)6HRtjB+1ofnD+t84F>Azg6o%UOlT2P*-Ljp8$%%+bOV(S9e)RE{}S!Y4g ztWW?VGF3&e9l~5%qnzA7wK}zfGbJVhmIzIX213h;nG~TF;ES6K|k$5Tx zOu=wO@mfKR`N&ig3vTwNtytCr_OP|aw3gy&N=S`JqMS84(C^$7;rG)Z47KCmSLJxY z;tS>wb$@aC37rDt9EfOkKNy@UmJ8zF(Pq(X@~8oNSLTiKEBr;YEG>JCf;l; z#!%}Bu3^n(naV_WKqyLp_7?Vb*qc^t0E&+%=+It?IVeef4mni|WLt>gCJi73*oh4A z=!RU{K`-$y0MSWDIYpHtPXaK781W(A%61YSTlfh>-A^Ze4gZtHR(KbYbvE%T^4Mh$ zU{C9i>~_s?k6k+^sOL#HdZu3v+Pr7?Qb{8Z)bFti+1KtIIOUWMa;|F1x5Kbf(bRfG zKEkv`jlLaMQDTX7+n8V|vrXPyTr7|bDhVA>p;v&-Q}oIL_u6E}hwLz}utib@yE5F@ zJ6Ser>E<%xFYR}lh8khN{LDH2vTCmI2?Z%EB%pi1x8;&^m5-w=!4G zS+bm2ig4m_tJ|L_2SGjWZI%8Ax{&S!0z=jfY&)TFe_WUpn%Mz<1OTx|w4J#D6lv!h zbowzLah8Kp=7!f>l)C!YZz#|E&(;39ZGr)=oR77vh1V~Q3oor*yo)xnTG;-*YHnF| zj5rOAR4XJ7jGlPf6cTGHEp%RF+v zG^2T}&X3n}jgQ>VClz1%DIgHaedAT_u!dmkri`vl&VA+RK;5zF$tjX59ZlZsFnBE~ zwh&HXq3*;Z9}s-OPtfXdKOEK zSRr+$8wVttN-lK;)@8~r&Pi}(dW(`8Lj!u-bf{=F7{l{cn7%7%W;FCN1U2H|+0}Z0 ziu5P5-Tv1*n;b0pVE-99S>4oBJy*Jk+zc$#BP{Pl^tMuFe^sLc1FGYWNPb5Q##km} z{oc@40;P#xwS82_Ld`M|znL9%AM6fY)^5lrbw^kASfE!p^pwYC>jo@&s-2;Hiequ@ z{x(0Ggmd}PxKy|4jJF@r7)Iqx2mHAkwjS`BZ`*>)rqx4PQBO-u0K2n$)ykC`=p=-P zTs5OkdAFCz$4}Jogv#5CbrO%k8{&$_E0Reciu>y^sDS-+T2TIP+JT_L+w@^q(ra232VZxOD+T}QsUMu zplMAtY$MXWrKai#XO(4;(x0S_x|gd7SOl`-gN60PxSJ1qp=n~^j5qlet|P5xd&(1% z>>h=&#Oo|md-AAOg!4YvfHY$`HH{|NB@tps@+@Wv3NtL{hHP)4* zpMAW8E)j3cB1L9*lSR8NSU9Irlbp9-cyfV!6u&kp400Geby!%Ekp;<*x^>pnK*NrN zGRhgi!g0c{V$f9wTQ%(Li0%k!K*kZJ6}kJ5O<(Yo-@^{#dDFsi-@5=pB+3hOi0@#| ztGo&6u#RSG;b?{|-q|5_V!2jeq+RDbm#W7;f(qL~>mtu@=sOhpyZ$;5E1!b=p!i2c9j5>HF@P z`|e{yT&@o@gkJB$iCPR0J;nW4Y@FmNU3399LXj}Ki~<5|=mO-BLUxL&5dm~KfrR8K zHi9XldUlEog?bEF0+fCUf=p%j>9uKJZmTw7ZNGR~*{fD(>mm7M)?&v6hN?(^@db=J zoCW3|pEsMCto1w7KbO;tV+sdqJ>HoIX^GKoW4^$QGlO~Fz5Tc z5eMC6voqTnsj#SnrOXU+g5eHC?VlaY)rr>!UHXcDoXlmxbj@Kh2)d`|=GJ0ew(Gn4 z&6Z+0ne?9`b{$VJzhq@&N~SW-fnlYU3`QiBg6iyUe(Y_B(~4r|x_ZBH$mysG$qcb4 zh2nj>s>uVUXG)Q@cntPpWRhccg%Zc(a20Z`OjTS-CkczYdY%H2hW4aeNV@uZIYxui zE641=`9(>$h><}CGok`pwlLY$Qs?a4R_!au*e6m>H6vj)tSEqm>a?h8B_b|!nd61w zT#B^is+D>z+@)DxVb~3XrCQiWOmjK3ehgR>`eHq*Gp5E}3@}dRPneB@h10PCHG}cm z%>k7KVQKN|UF>O#ReugJsR}*P)TzkqqN{4T#ugL=ShSn^U=>@r0TQ}cJ59ye&u@uH zl1^n@+2n`XzLTwaZELyZW-L|RUsOVefEQlYXnuF(rgyF60r*e-8AFz^Ay&(Ia+l^?_ z?Df7m^c9I!72)-xJi)7cV#HJt-RR<9&h@YpMs|=!{k;mAE2z!;W*6X{ae+#;AqG)i zdR0MQO#qo~sd!WSD#|-=qQJJ535|KfqT2`uv z?NzX9y4Ksmf;SN6E!9PTE{qbK*-i?Y+6TD*1t@9*F3si|6Q z;pi%hgiRNOO|9~6gAWn#*$M)#+PlF|KKP1Yw7D4@9-Y7!hov@ZG5~n#I2Uz#Pme2@x^T&VU6c#WQNnFGYc}_|6ii1gfBLaZF7pSjg##}YibzIStITX3&{VCTc~?<-2;COnAFFZ>EY9wex`klD(;|8YYm z$U4oy$xoO)`-ce@{@+@i|Cdg%5%RYe@qe7);>~qneT_O|EOGIOF4b_<dPMsQjUG z;0^fItKcbcjmJK_w_F~M?#6w#X;+UjMh=Dfaz^R*vx@KNeb?zLmIG3Tm)h+^&*S&3 z?Y7G+JfH73PG3GxbUp~<{F6Z??WwyPd1U%d>^??Ul5qCP`==#x96;@sMW>h6@E#92 zzzxLa?u;74X2O*$9He!8phM4;i}tp5asW!;giA9eF0PIee;F)&!D78QnStpiX0N5b zkdg%r9M@(!yqM`<1r2&sB1Xt^nuZvgxn$XG@>f_n_diguMnbf;MYIt#c|vj7#(r?} z%(!Ec_z{G`d_WXqZ3 zWQYTPgN{_8*jxB;Se&UqvnD%wXlpPyMh7-kVnC;79d^;e)b{}E`Mb=44L^yO9z%k^ zu4tQ`D_@0mO>~IhsSE%x zc1!ZwI2Bu{5)_zS!avcG{(mKKco{|IJ=67)Q z9$!u3TqP-J4`y#zD{Xd}KST&Vs6*R@?PFTh`<5(yX>@7oR+F zdKBIp_I=_TUf(KPbp1Rh{ic@-1;q=Wyj3D^vh2*a>L&c zf#X~#^8j-FUojRzy2jE0YT(;1So3XE;IlbuP#;paUzAZ(zk%b!LJjl8#`A>M|HdCs zPRxb#Jb+wyGyyESMNo zoK@>SyksXsMoDzl7lKoi;fx6r<4GvKRytKT;15E%@K-4eyJi6PQyds;ZH(!{=dUT8 zK=LaA{q8Zs1B|3$x}iFo4Phh;@f>_ouW*5RljtxI`$PFvg=Bxe{o&0Hmcw9n{x zFL#sIrv=BH8GUnvIKupFgLj^8mBY1TqwFDbu85@AkX!$l53-_^HmQoSYXqn*37%kk zw7lM~10r%p%j#=1CMYh!1)PU@_nuyZ!K>T^cGq{2P&wr8R%rGY5Pu+26h|?f0$qMW zwo{4Gc@;$!9R<~HzKjRzY0+)H@T1Ec$&`M^D1?^o4f3J_^yh(nrRB!!K$qdNY+D?d z@!cL<>ER-TY6^FtcQ~52yz?(uh-&V?j3w2f$w$kC>#IS8>k(|KT7_k_3vEpNQ|Wp_(;fHiN-^z=U>M{0>)2+{2^|<`>Zn!-8V`{>|CSamo z>r}i{^SREu@Fz=pX6;|#<^?=yg4gwo+w^_5gY)-)X~7o*Ej&znr4J0 zC{p4Z5WWj5Mp@dbms$7g|6(>1PyR}!s!DN zn;9v#5mjB25IVbC6`LMWcr_BP0{t1lA6~&}?MpW06ho55prfC`dByHdBw5M}z+404 zl}!S^rqULt#VkN^d4`k-N{D5Jd4l_5S}Oa+$xQQeabf3+R(Rr=VG82z>Cw*fKi@O6 zlc~PTvS7#R!=SD12?^!Cumb6M+0&DfrDgZyfzpgk0%NWDF%%S0Bh!Tur;u!&?nF{x z)ksUa1XopS0B6g`T&-gWPJ^nUQ5u0PRcc%G6aKnh)pkuWfp>pe}4EU6je=kipe3(s2~XyhJlLb6IsrdEDGc370W(s$a!^C89cUc+kBRFTexT) z<-ayKF*TZ1BqyoJjFyyZm3;(Mm1%nw<(f!cR%tHz@^-{3xILkP z*7~L=)paFMK3_2$)@xFaXupN7LAp=y{RU7AU ziO1?uOnM0X$bjJA{2mjGts#C0A@&(%sjw={5#{B;-l1vwIT`Bf+l}hi(cbna{TC^> zn=eFHAD|Dt^a6%6O=*PA$(y-%p_>gAFj`w72i+LXTHNJ*ppT)zjC*))lF)2yLKJa` zTkNdko7jOkl1iQaV208vH$CFxeoguOoo~@wf;+Dbeo*JlHi&P5#mJRq z8iRejN{PuiQ;mmQs*Qhkq$lk;(Dm-Y@G*Z;JK&LH^7$@=8&(5Y>Q?emkMIj)$K}uQ z&ASA1fiy&aIF#bF11>&?YOeO5!xGW7VOrvlXLuRAX}bq%y##94f0sdoR^a!@e-g=Y zM=9oGfFNFJ3FV|Nb=mH?H>-n24M4B^w7THk0(a;#Htwldpj~~bUFtI4G{CroKed?X zAUr;PKRRj<7ahC-Ri6cA%6FW^6GZn@Yx@#w7baqtBzF39+)}O&S)k`8L$a z+l2mJmP3WxXVP-AxEhDRA-iZoNI$Q|b`;C@u@&u4vnH4wsL>zk!!5CIEt6+Tq!nxC zxI*mOY^LzHD3GKM*63G=um~)e31GNrrmjSw35JH#%uxvH+6{H0*!YggYXP0l2)Lj; zzlm;Qzvx4!;jo?K3aRSXdK7FurfxMa$=B*Ps_61BsT#GHTO?mxo?R1WlEVrN>&j2j zR)iYXdifu%7R1lh>Hi4AeSd!aV*B6Ufc|fKu1IA=0b2?4J1dQciP7@OOLP2zkQ z#?3&}e0UgrrUZCIuv^5a4H(!{wuixNQcRZ>t(A`9F4vLwtQ4+P%ArytaUH;fPcN$u z^#m(*Me|RKy`+P2vNsXT0%c*Fefzch`lH)|Rp;YwSMApZ9o~R(s-0z@AU1~NS?%5| zUD4`-xsza>)gxOukwy@k@#3&tg(mihtw?5mHR4o7NC__E8NEi(eyc*&l{{f{G*b9h z)#5jz2+)AzAMfddje-X z{k1a*t<{q4SlT6R!Frm$gQ3lGdEC``ddvkUm2KQ;#&$Yw%it*Hf;FZoQS}TdG-`bz z`gE#2xwrT1@*(E(9P32Wy0V{B|5&3POunL}aPiG*I<9u^&A6IyGWk za{31k)(bpG8W5SrKY6ZURQIZuu$hDAK$M}(hJy8^#le?illrzPbKp%F- z#o9%Xv?`V^u4RFWy=ThlgDIiPt`5PqRuuEZ8*wPn<^}U%Iyy^hUk!MIC~EV5#+(Bt z2w5_OIhk05w~oH*CRE1Zh!@Q?@aKE|HN*|&Fkn&YAjs~rEsVLG`Fz?MEBH0DuYh>% zZ|62EGwQ0FmCl)~0lU&gM)-a#AYw4JIWSy-Az;nlIoySlg)o*wLEyN3zJ5FpSgU1{ zyyLS;KsGz{nM^lqUq(CIY-5P)iQ?!e6n`2d{e{D5!{l$XW#D+;7E^9Vb?Yw=IG*wlyy@IJ5iJi5aD;GKy z$}&!aaWaS`ul|upWe1l}GlJ-0;-w@wOu(KvqvGzXw%@XnbFDjsnwyN%u(+kiCjzo$ zLec1BCAa-)FU9w}uaO!eQI1&63avriPNKN=k?Qm=o$@u)(_(zAg;W`5M}L{Zp{h%9 zR;LLE#<*6Zs+~Z)r9RV0jGn=mCOPiSap#qiHlAj{%7nJ_;pM)*cd*s&u@0zHc?93d zS9Mdda1>;Pkav=hs76BBGk*LvQM_a~v>o^y`=U4KC25lfo;_~5>mQU7 zit@aGnO6CQZa&F()T~WbP~%yl-#02}9L|(0;AXbV=RRrvy@U~iXmfU9(GmorXeiUR zc(a#^`^b5EK@W0*pH%5#rTRaE*28avo&#lICuJ^BH<!vu9>!=7n8lG6+7n4DOVV zkbCb-IG1?2;<`Y?q9Z1&t9_RoO;yDMDH-ElEZkm5-)(CL&0 zYQyY_Yim#8|IuTuu`yPy8D@4ghBUX4b5i^PgfXf(o=!xs<@r`4y!0?UrO(H`O&m?^ zfzCxZP-PiIsEL~>c+OrnZh%r zog2sD8Yiv@X*r;^9re-Q!vyot`+(%Lg6aZzz_cw%VGlf@?;t4fM4Rp$HDX(HegNT? zmOvp#YNP4_Q-VVTUQFTmX=cyJVX(~S>3aTkxkP&dq46mG@mB^|eNy$(A3)gl%yM?q z$2Dq-A%>JiY618Qona>T70GgM+ncw3PNK=Z>ht1U6qJ7Jul*P7<)iut#)p|Bu97Cy z{OV_Vs?JBfSJ^9voKR*!X_5*dLC7qDi$O;xI0!=&K^q#8J!rw*ui>#Cq3E|SOQL@3 z{4U&m?}I;Rgg)p$I?-Fgj&5sM#qaA@bXGLN9Kh%^>cJnB|J2N3E)WXyJ_pOEzc^1C zRGrv&Tnof&Ymss6YdiDgi0-PtypW+9A=^hXB7q7qf3RDPX=C?-o zuO>hij8=`2-DY$JrGC%<&>Rh5+&%gJ57OQ-NVjiU_gv*wwr$(CZQHhO+qP}nwzo zzaf7jUf)IkG3P?5SEqwcy3V5Iszpch1!8=x>w7lB6 znQq7H_S*X1&$m0|K0z)q{P0W+1v0ZB8}qhkP6XuQ8X{Cee+NKU^nL!>J4ogbht0)Y$xCmau}T)#jvo-3w6&&oC>T&IVEHh@ zt0FJA{T@yNfl89J#6w#zvP0ZQ0{-IP7yr@eJzGQ;6X{#u2sz38W^32Ibc4Z!VA^O; zRU>c?rXuH4w!#CP6vVRAvVxKWo^uWwef3deEqyiiWim7z*=yFFh(pWC^~eq7jEqo- zlM-^T-a3WCi*KV6&ku_QtwitD)*@N9W|U?Uab1i)2K04q0f;m!{AyEi4}W$Kzb5&w z-zG`1^v^j%XvgN!iSSF;V{kK~CSwKwzvGJx)rhJjJ8!6H1@*yC#@~W;a*U&8!_aa2 zcm(mwR(3zZ3&af`!H^zJ(Z~oUVSuP(%!ocgJWlNB7n2ZiRpyJdH_Cp;mF%@W*2m!tcr;y#W7yosg513>f`G5zhIc z2($dBEAxNXa@i`9wo58#+^!=tTn1tS<3)mt2xesWdFkR1AQ?==K>|2H>cIHP+t`NC zGEx6fgj1+Cjo0y~sTiBMS5ZmIo)0}H9Pv~qQ`&O$LDt~dIfH1pi;u$ry@RIq%CMm$=q^?g9&1kRDC&0Ul>j5u@|)ByGx8DY-Es z>0W{s(9OVSj%0J_=sLT6DREv_d6WISJsG88ofiNOglm}6fYBC$?C*$6R18>-fi^4( zszPs>7Zc*ooJC(36XSo;rk__$($i<||CCo68F1C9?f>SVPZq%>O}S^fW&`^sT<_dr z3sSLv(@B%K@txKfXjpR_65fe}f9YwoLN{q?8{}#VBbw9$$A%$%P*_;u{Qx;7?-MhM z_BkQRBA-^Kgq-sfNcPre3xY?&o8VxA^q_Vk31Mv$VGJHldA0V#1q(HmVkUX^EtC=9bI ze=P}#;91oJ_s-sgvsmdBp=U@c_pTVJD>=ZHIJ$P^l7^HyB$rE=->~(5R)PA!fY&ra zdC_2*d$=N<=`MyOjqq|oWBS|d;d?Gq+BY3Qg?l%;OuT< zd8Ys3bKe>GuGhkH?MtuVy5mPcAE_uZjb2pmU{kLCU+RDVz{|FYW7U6pF9iRu>~jCn z6Z~JD@&Az|T&$w~4@sE2o3pdA6MZ1mgm@go;Khy?Dza>-%@2pO_!L*sG`mSH~+b^Qjlw^`d2&kUyZKtR8eQUAw zn#t?^IlC5s3z|DzC8}gD1XTfT5FDAdByX<>s+XwS9z7>+un0?LJU`3escA}PT;BtB zX3zMnyTCwXxQcJFLPwjPgllk~d-IQ1jeU)@TFRd&W#?69E&l`KO?8TM$r$Ui;Rx+& z4CL7+>Q**x-y9p?^_G+oXV=#zpZZFGa-z5_`c$fIO?xQ+KiLORGdUE{&o&^Do|7e; z%cOE^>eW*Q}|RCAfz!#!JBehenGac++5O;P2^koO^sm9who=9HVr-5jNyC0U{T z!V3o$xld})+IdZy0IaNuJ{|QdV5rwCnC^Jon01*ZT-|p#s4sCozFiX}h+=8YHe|+* z--Q4oE{*Ryt2J%Mpv!(n%CsuZmgK;cM>F8RHFf4%ko+4G z8F246b1z8FR4YQRUiP|dr|D_dDo2J24vFTlQPggyEbQ%v@7z(1uc8d8(vY_qKLT!r z8znjbMX!2w_@E=G;(k4sl+PZQbSOSA2aBF)&(2fs9B)IfWXqzEK|4xXjOf@?jEF0` zj1q1hT_$@n{T&5>2BYumT%ikH1&-m~`;Xl3pqbi6k3lbrj*IE1?J}2mEU4C{-(^mLS2;nV(571N! zwjp}rR`S$1C7Qy(d#7K4gKU5=IaH)`;<|;<4%$uIU$#bpkc1Q-N+iISA&2NQK$%A@ zPoVxkFk!eyNux0`9h6{7v!7asrb>`nt9D+JP~_QgC`mR>p$4zoD*|Z3)LDrUe;ExK zBI(>}%z4@2a>^NO;xoMI5ZO#aFY6PF!aYC*hY=sWn$SMlXXykX)&8hNmott4e&xz4 zY%Jn04U*uH`AVEs0z&+Wq)l*_qHC6s^efTZ8tCH$=|$hW<(~Xk&>r@Mm^H}vv2I`P zelPYj=*cKnKrE|8{fP)Pr&;E89>wmpT&$rRi%_>XRB#I^N0M$Ri?b89wB?#^-u63j zMxol~OQ26AgOl^Y^Hj42EmnZUGnh~kuKF|SUuB;W{v%W;vfcv8*XfgZ*f`6Rzy0=H zqaE-KWcqO`M;%y?VJnZ~vSSQm&5WzqS+}%hf6uH+jFWEjLMQzc%sf9AP5)V!<9`AQ zCu#lz6dwIn>}a9_YVz}Q>z7>CX@U$RkhA?a0{49`1I<@$}fWoc|LO(#^K-@mk zU9S~b1FlBRcpV%F^M?Cec1NF+DR#!suagVbUyg1Ip*}^*c1B7H>d5R{$>%u{TukL9 z#m*uX>g89Xbf|+sAv(UJ4+@J=?Fk1fO!AJ{nr0n_>LFK|F_-3;%i0Nz#G^Ibs5>)~ z^}RwiAd4)Y1cE%?puJMT_#OLJ=um>hi!3V_p2~yUNXn5aA(AmPRS|a5?6y=Q#vV{W z$ok9C%DZ;K*KJT<%Pr8Z!w5O1aqju=SPIfa9OG(^Yp(C#0;rv#C@i{E$oJKUW!7Df zXIf`c=Bik~rx9GF6LpLtB{P?xxX-3Ake8UBvVaKF6p}?Uvj)NrQ8wXsJot*OYti2( zOr}wMwuwiF9G363^WVQGm3S`THQ<9+rXrJqG+fSWY`7SWlSek?-OmQ;{rF?>iP&fk zB%ol~k8i^a0Tk(}9H{d9ZqbBeD%1AUhKOS>+WP5yXLJ~-T&~x3D*KNU6{=y0ybUw; ziMm(HgEvdMky!{Ao%Jem=9~xb6&x2IPMa9Jb6A~Z_upeoC#d_8)rO(E&18H5sp8|1 zNtYo>CS`VsrgiWIc=LEO-vLvmvGMQ1OSsW&tb*@=2#ZDstkH(q;K;%a)9|K`diq@C zLlUMf_Hq+an}!=hPuWEt3?bi5`(Qo~pr3>mCB%v-9Vqn8B@yJueLy)yXvfo@{s31` zC?)HLQS{3GNwj`33X`Rpq+IEvT_m%Xc=~-ill(h7nI+31AakghWefjJ19q1>rp7z; z@6z*0fBdNQn}{7`Yv3)6Gm22S-1l7@pFUf3Ioa2LJ0A|&88z?X{rZI`_v;t!e^Q12 z8&>#h;~%VWY$6;WBONFaUtb(t06YRXoS2)~0AUw=)oC1*K3+QbIPfhl6FBBMG{|z~!~*KV0Dzo!!<| z9n0K5qq$tKQ1H@-*C1m^jGt^%`#*D{OE>y3xW^dc(ij)U%AX}Eb_^>}zF z5s_`v1%73y&;a#nRDU*$OVmsjm;vU=Qox2F>KX7UFGs$H{69sOCaMNDhnm*sIHF(G--d9U@8tV9;g+5|9-A*j%p-gtFnbG*no7El;F0 z-6|7^MH8SST^e}GIfcpa6iLk^7eNle@M!f{yEJsGX6#q|(k81p&a{-WxArsHVC|Hu z=j3DFx3KZdmi5{|$_1Ch-dzo!%`lMlL+OKM^NPv+do&2s)16amvsXELuS}}z-H*iD zAYbkELg0Br;xaVt^;qmhV2^3p&P{d&r%OMq>TSUL+>r>Y3pqDjkgmBqY<+b+$nEtH z%JOKC^~H`)ZYDse;$Y%UsfsW|!sU0vIbyilXxECFscF?B(la;&O-%W7NgJ;Aiil>X z!I|hTQj%(CIpZ?CwL~$9d1@p2_z6DsX{wKcnzZxhOr|Ur4M<5=SLzS9HC%?L z8X!0$XyxYeDko)5SgFM?Mf<^`X0~Zb7N914$^G!PhME@X`k3W;>1wxxUf`S7nrN4y z*By7WqLv{5^Rqr^zX`jNBFatAB5CYHwzZG_x8Q{ihWLmP#O%G_B>MKd=p)?^)*mdqn-7y`@Ox4YvoP;dXoaO~{-T+Q+TkWu z>|wvD>y->gKh}=TR4K*KW(sQkL-m+9rLpooAQfB4GM#Hg|00mEV{m>p#DMKbx0s!< zprObzjk*YMVTC;1C!GZb;@=rr)t^-gZ6!^ulWx`NY3m9a_7`kTsTda) ze*{LU2Qs_Mt)QF`YTeTo_b0FWn%|r?I4F}tQM;JdyZB+G-%=48 z$#4m_)Emcq204s0#C$Vf-B`Q8vHZIB(N2Q;@x6BaeDncPh~VLB8k*MsT{d*mMM{#zXZ6xIGcN`FayV zj?*$kxF08+oy0I)nDWxXW)(3?b=$^fFpmrz?%o}06G2L4ujG_jr;3F*D$Vk`>4Zip zS^`F8A8^%l>f_Oea4_Vi$Yma0DpXGlF}#T4%~xCS);Q#PT1QM^HOVi@B?wE{Q98V2 z2uwY{vJrzKlqqD;{i!=(a+h8=9@)FM$ zV}JjLn8SP?=M9S@yT2q7YEYHxjmaA{a$KF%hc3qkPKo}dXu6>D49D*K+)}vOB%yT})>eDbD7I5drb!>}+imHIZq4f*Fb zlSHu#cdLgfWh24r3Tq#^_9$Ez>Nawf`qp+IS`rFzu-@f%nzrunIe)G~i3!>9*3?PU z$y9&#NfjTZri8lwc)+Y8j@8Yy(YyC>Ff-*P8Ey81eO%@Xb9SzmZta>r8z;E=p)Bt# zFn~L|7iQo9o%2wv2z00MTI6kw@v0fm2Zljb(3q?54TsrM!*`=B9B7hFZX<--Dyd z-^h$V2F@1rTv7}3Q{+}4=CMYsnQ20qm_ok@IcNXPL+9vDo8o+*Tyuv#^C0}#xIVl5 zXne+vqKB}B%U!st(Ek3MGQmYgaTk&5Xv~6>qabS&E%P9&&@GbIJnp@|>?Sc>?HYmf z)Bl&PXTwLnx%tz(OnSEMb%g6s3NfO~U7~d+{{})-OKYo+`lk6wDvtZAW#T+}RgwBI zw8Lg$8{4EnCUNT@8tg8`3B%l3Zbya%;zL*aU~4u)dk18Fk_1i{@*twa@l6EDbxi!O z`cYUt*Qn+wik#I}5-C+nLI$NaR`!XRxQxe?q0S!31-z&UDH_k#3iP$l2qT2h)k(8C=}xBfEvDp$ z%Eu0p?_S*dXp}N%&RYBy3Z*WB_2v?ma9@l~N@FZ#K+8im`Oa`!DpBHQN1RF5Vap=C z-sqd~ypW@1RpXcqd*ij8%xXMuUe>mxrt!Bo>7zF%?Z!q2L{(_6$TQ@gUn~4-#y&6H zE$AUSk?&_~VZD(854c4UUUU&r^MMB^y!n#uq0v+hGT&w?@qFVZD=}5_ev&U-YA7 zH)vN*9pSn8-1A&_i(Vb*s`~D@d9?GX;fKhYRA#s})LECVt$R}#HqJ~l2yWhb5d-6?!GlE@KvU^Mb=21;^k5nhyq)dIFG%L# zdH=P?$Z7F_;3KjKsGhF#Vm#6dBQ%GMF06LKu`Xn=C`MlrX->-X@S7&A^heZ-#!wIZ zS1>aC0ExNdH27WfvR9cmKv&Ir1AMqP5Ko5@&fS}ci)H0#KqpV~xp=ao3yp5p2L*@M zCj*DoFG}JVwYJW-k$hrA^ybd`Wr94xqnP?cY9c}g>*Vze;M>^Hsj5IBQT;>BeU>Wu zR~A+6jqeFRuTUPZP=+Ty+s+F(v2QGHgF?^!uen2$$aP+C?iG?RA!7?IbVm?3IkO*_ ziDk&_+hd;)TrYkNZ}Ypd@1JAY>zIr%#y%vtwo2x-#&XprxCSSju-KZ}+V5iIxpOu~ zFnUCCa`D-dNn_btVo^D`6QDgOm}3zMnzn~XUfHK^ZSgobVz=w2axhuaXu8pQ56aI& z$xFrPL%E8ZvqpDWf15vao$jyG4L9mL`CUzh2@Wza!z5!|t752f+=DnCu}3&9vTrNR zZ7P#$S5OsC6xco~7?YRgZ@C=yf)xTqfyA0kS-U2P`U=(R_b6e)7j7Wlaw(oIQ%=XB z-{IuR!^@6Q)!s#ezt1h1E@2UU;~*WC?x1Jm_=Y3BfSMd+{^so!nRACM^uqk{9c7B% z$(MNJ4w%_w3f)N#ksWNC)Z5|@Ldq=?o`tiZ2aefbH@l~vGQoBz8EYQ0gRWdT>IY;9 zD4m;NI^!2iV*>mJ#t_~KMc{{>ADn4><^vvWk4G4$2n@w#@hhR7vO~d97_2A!=7lfZ zbrt@KpBRgWDe`*!J+(aNP{y=neJGY1&$GZ&P)EPohnW--BRq*+1Vp@0WXN=GM>2yZ z`cz!aTD%~+*-9U6w1tcu*I!pf#w}C0dTWMmU%e40$2cY8Slr5V$SrfCk`at>BCGtm z7e^0IXrz+2nf7_eE#}^rIbK(}z~y#6T}OLK*1i^obr+@u5r&^cdPhbTvS1c3izpOE zG4#6v9=-y(&@3H|5Uf#wphp1OB$zSnmo`xw7*X=+ZMKy*cb;UIrg_L#M#s{OT{o%^`Q5aYoebQc4`&5kU|PaQ7R>4T3ZT7XrP z3$dCDyQ(CoX2!WoHoyJQ`$5o4EJ#YeoY+CU-@@f;YS} zFK9eR(i2I_6D!S1TUPu<5rHlixGD?^bjlRSWMQ$J{ymHW3as^-Z-()qDsXcf#-W{$@4aPZ&beij5_F@;zyz8sRPqhuq?)sDm|J z^Up*=G(2OC#e7_sV1!mpm6zZ(k!~sl7vYN0)RpSwva60bUg1d}s>Fcelb)^}smrO- z*%ra0O+@>>M*6*y^m#GreIe+5G3fOm)9u2f^#-K7lbRfFH|cB%rbc=K+_RG5Ulk^` z={e40KKTSa1PEOwu z9v<-ouF*Y(`hEWuxsYGrhwRiJGf~y_Bkece0H1Rsx|4zCf^6OKFQQR6C`#@FIRbde z_ejyYxw=kKBwUp4`Vu-X1U$#Vy-bIuI=}-tVYEoU=mQW~7?JD{3GoE{<9t<(_x8$l zL%1C%GK0a$NezMmgGtQ_LMt3@xWK$g?RAHY#2`-|qQ_6xKgbSM25gST^+f#A;}cCr zNDhICdSFdH`~vnvnUp@lL?UwM*lramPSaVzjPXjc0z%ZB6G@6xMU?QY9y-8 z&d2Jl%6Vwq4G9jrjdJ}7e!NH^<;jQ<2y@>T)&DXcN7N~KmdF8~H%UJfkFf;cDR*;N z_!Ca;ih9VvIWhJOU$Rfm5&B^P|78ytel%b%w$XJhXI;t!220>r;!8m~uvUlQkr)7G7zY6wfC;OO`!o%?Wr3-b-Luv)Z zo$s|{SLM3e!izgzXDAvhIy;<)g0R4uSe3#k1~JP*DKZG!ai9*Zpj$^Vduia|v_r#7D<%oh>+t}uojz5JfHJ(4cZ@ic8Jp^@D=(;Si_PrS&@#0CL#{WRTqeX4jz z2yGmkI$5YK+{%|*5>+pLj>*7xwyHX2Kj8}Zyr2SRFNvR13l~c^G)gff>Hk8DwEu)<>B?nhyyr!O>S)+# z$TeD5)Z4haL9A}_WgS@4tgG7mBvQI!gXvVwy{K#%dtiwd-WrU~m+`AX75giy6Q(u4 z3pMct6KM`cF2@BoxcS|@=}9^x&pVQ$DYQ()Gw9edw2a>qDe;BQdJd;hvYFJZ(q&3H zwYA*8wY;NCeEBG~qQfh@VluU|!z;dG^5mg>a&sxkTG9En7^rfxlHvT$w~!S}s1q;k zmh3S328Ti~H1a@cg2og$X7L6A`^r7;Nv)8W0l7Cyj7`1^{=bQC`v@xEdKQHe&bSQfd-=?6(B(4h@%R@y!NmW?b12z9#lK;Gl8O+RXGS#aPVyPp(UtJLcTD{{v#(%3ykmw;4ZE!OI0pSwrVA@;8Mf$T^n`3a_E?7DvD(?7(* zcL>QnRigQsj{8fBv8mS}`W>@iyR%8^Jv71w*>994m~bq_Iv}=R;!za6S+DL+f^cLK z7l~`86+!3nm=n>2tfY)ve}F0QtEeYqEwNDkHOjaP65VAsYMg!~+!3~79KZz0_g8!i z?>Er))0`&^CrcuJIwCxt@iGuo(II(<9rwUaRH4#vEDYuBT9Q|;*G4Fl*83VWCV{t! zAdw@>1CfUB$mI4zs#Qm&^){pWb5)_zbgakO3isinG)4{BjL5U@?VZP)Cd+oC^)_>r z=Zt*D&-;s+(5pXl-1}Be-`KR@iC=$&0(%dT2ixK2^=J?pKQ;zs<*_MqTY)WSK1$8{ z-wd1RuFq{c%*b)5G+5C`-)t<#GNVP?bhe}=SN?P%ssB0bvb?R!Ou^2{3Uzuc=n}x9 zbMzHL@4R|LV|c7bnu|0`Sc^}6od7Wf=~Q1Uw9{Wd*Po|g}fz2OAaLglaRp0i@g;) zyI&&XrB31zjh6iJ10kX|rFR?2_elR7?x(q)-`J96H?!RT!pq;OWq6eE9dau{SoR>Z z^TVL){XA0US8u%U(LzVaM;sF`=O9hE=MpYz5sS%gRXz%twxihq8RT~#;Up3Olf`CU zK%WDJN_jwcV?~sy%GdIyIXb&1D zE`DHkitdSVIm0{!{X}@H@FCw0XL&x)EE=o@^i*Jq=NS^n5M;$$_+s4`pwWg2^(CS_ zEpCe7Nl~AbP_p(-cx3h}GnfE)6QUWwU-N{ZR~3BeQW!zPrY~E3rDMR3tk520og2=( zfEg-ta$?`(BR9q~dl*{_ZgmmHp_5O9Wek1-k8Tc(l(+N}@DU7)El0XN4v!@>=#mX6 zjNZfj!=85!F~nadlRF&8F!jdJy+Gz!vVh1SkORb2PGyv&>VDLULaT?SLdR~THz#29 zik0Vna_V&^1yn_yICDt*?i|C&oIwfIUX#J3*dYhRmAnw#5&7yI)A?8BLo%dx@>kxy zC<*O;tr#gOqIIa7QgZA1_<8FWWknZwjn;0%MY~S(PUV$E4aO9KH|*L6JH)vsxo)q& z$Qf(ExNecbCrRClNyWl5KGBv0<-?|Vwhx%~+_Pe&Pby{VZbjSAUwfyi{OFQiv4c{6 zUM-_+%lPx;U$H~d?%=a*YF0wl4rTu?xM zU(Li`zas4;P5A>DK);~hp1#nbAd?2K)WPE@oET1N`5SzP+;vIto4rOkZ@AtaQ^2^Z zS>hKU@gu6XX6Gg{)IVX2Uo~DyN({x{bd|7$8++65_p)~*i~z?g9sG`)h<_wNgdIC+ z-OtfCq0-E#x^Oo6a|;s2xNmw$5b-R#5JYx%;8H7 zC-z603EBwQp{ja5-y4C0P)#B>GpDefj`-P|jYjvCxQ5`8w58|gsrWY~^!)d6h4kH0 z+1(Iayy%tg^dY(B>-JpEC2c(H^k5wMx>DNp;j<;EL@+rE^2}u3KphkE3i=YzOQm@q zCEMHiHP8+0ub0qYAH4uCqQ5>6Ga?vDC*YI}Pn*{0%+PbHL!LbhbdjUw=2R%mN-4}% z$w;gE`2-O*h9NdUAU4<`HqLqGYUF1O(DlJD19sATfU42{gt#bREXKb?mSH@goPbd% z9?|+l{V0X63hHI&hcB|77;(jH^?F?viN{D{=Sy>_$?Yr@RMoA3$3xAn(A$*^po$#` zcZ0u`Oiy_zP);5yq)R~9q-%Yey2zgNLYMcpRB0pB5`j@OAnJln-mc&#bxe5YHg z_RjFWZ;DEdT)nS>@CkNI`@k3vIr*a1VA3HNQuSE0#$=(x421kI+x%#0r1e z+agIb%@mK1pjFU8l&|zz7)O;Rj{s}fN)?sa;}A!QJ0;Vn*Dy|;dNj3rD-93WQ+8KqJJ=5C|y3jF&Aw7{%`AL=(+wQ9hLxnpYP`5gln3BQJ{?O}u18 zRZJ~H*o;0|KB>mf8LjNpT(1EVew#Mn(xM*ToCNR)Foa$pSHg+b9`F}~UPa(IpEApe zkq=v@C0(={L1aehAOQ*onaHYLln9{4-mk&<;jjR4ERz`ZDC^8{W;YkE|Czi1AkE&O z3z5iRX2j(S?Fq^E4hd`=%Q1^adUenNb*XKQ`SN~Q?=CynxVY52$8saH=xB;jSYC&^ zn~H>u0+nOgF3*(K+prc|b&g8g0qiYlYlel=NQah0;W`)AWzqOEobz%P4Bw`ejW)7v za#m$4r)ov`=ZCT&&BJG+TpX#ZOTW9E*S++Uob<5U$%Bt#79~z_-P($S6Vuxufz19e zS@G>TUuUMWd9htCse#QYhiXFUM5lL(+wp|FfGg6(P%oo2;=a*o1s1lQ!(_wB85M}eUvQbJUu84%vx-;K)BmJ`qIa_6pMLOt$p)}a8sU`{2x z1>4;lKQ!X&vE1P-2})sp6UYhMjHdmLiJgrN0R)WjyqUo*dIZLB5%3JE9AWp-W8`i) zZ@4QNL66lY%~L#$4SZ{a=GT844f@VRyYl%N4NCu+rDy*?&PvEQTUqHFSQ-Dzkomtx z8~;oEoH#3sC=WN52RMtEx7{^x32`t*b%H$3yRo*;1 zbQ`Uw&RMj^huUVgu1xh@d8mYW>b|y@$Fl%oyF~?VzP0R5PA4JdxgBHK6vj8> z2rn+c2EB}PC2k!L79}K6Tn6$PatzSS)~oV*^NKKGKWCkac}J`5)cWQde2=UgW03M( zAtTpd{_M_-H*&+dAf@c`lHQUbdc{k8U8>H9NAUt*1%HP!cLi zk2jGS27-pIpSgKKu$_$ijLk}Gy~8m)8Epi(Gb#vIl#kIZ=~h{P}- zHv~a^Xiew^r)y_kC(CXbV@#jU^7GEei$YsR6EH%}*8^8XGXEsFv%gy;Ob2!+XGaw4 zA&jPTXKrls2$)l!Cz`H5j@&s*1u0LJXQs zz>&WUk)3$B04*BxLjo6L$QT8D%w-@1Q0#Z!`kmH!XxyCg>3^z9mYZk9`_7!edG^eG zpML+@0iZZ2-66+PR15MZ`Q?+pCW$;r;F6w_<%tZe)!KzqE+Db_o zjr(~fyT|1?Ifl>I&LmF&ghP;X@R#rz9f$-a&?2C9H2|x3wtEX~$vw%v4!D(Cz0-jV z9Rjf)qA`9rG9dWSP%>oUJX$m_q;?zK*RWXu$)4-3=TuV4^w6;9bEogg`%L@EPVCig z52PL`NyZKE8<1LbQ`8e^T)$t`)3{l06wKJJo}UjGG870LpGLpkFNy_+8}{~_xDR7w zEET(;{NcKo^b~ze6LSSh3=mM4g#7Y?S#yzbvS~S9$;yeH41UKRqYLDaJmbtGi`xDi z=BgSZLD`wADWazI2=xU7_eQm)dxy+qHV*HIfuv2Wg{pP<>MdE!#iZdGI-=H<=0?v1 zey9wPY>P>BVs9rO8;x2ivqfPH^=!s_4SR)3w1#VF2z3HMv+pKj)uyiO;sNH(qWxv7 z@*-8x$PDANCIUrSeC^3UVTzlDXS2z;DRf$}4j%hr-$O>eCC~KeAIRGa)}Xs8Qzb2|oqR&mYvy9?KQlk|5v2QSG($W^I7M%)=uY;*}Zz7gA`G=|w>+LhAd6e6+G`!753&iqePi*WTeZJI-EzQ* zQ&H!xQg=v?8-1=4Xm0juU-8PFe2r$5s>thBCnnr%UIfm%$VSL`gsLoh9*4$-O2Ma| zTr^$kY~pXqiEa45L3ry6^}!XN0#7?yXd2uK*R4t4q}jsvU@{#Jdc1)hGWnuQe;`}s z`DAutWv>CV#RnOm7N`}kWP4_8z_A!cW`;1!x%*&XI?fr^Klj=2Qw>~;K)1hacgI6T ziVER7Lt_f(njyzis*Ubf6Fi~>R0|+6K$>;ny$l568qN!o)tebvz(+SI{88!vt1Mek z{d0l}zn?nSuPd0=8$;F`HT?li^n(2NST+85m5%Qd|BD6Y-qkKk*EQ|32%=Lwt$Ij) zOoKZHJ7_B!jUL>Pbw37B{_g-wgqNgStb3OyRhbE#%<))yfUlG54<;#q3PN!{w#Nv9PI$(=}Xz>r#~&ap%v;KR-&2`&z$y z)jy}gH+v*pZ6@HZ=n-muH`=x5R|7t6z%A||R`&?jAA9}YQC%I47O^O^IE(eq^G@LX zoWHZ$!uPr}IED0Ulg4$&gvyn7gk+f^T26KN{HjJ~fjr9(beZz>FU%7vA z%iQ5sxQHt>P1aA6EKD*3*WaAB9)y`@{SKKwK`SL0e?Slq^PTjrvado&<u1TmuElQ!e-4H$#j!XL%n(_^q z@a@<5qSQ{=t;_kAK|O+fxZ|x4{0`>%VrBTy4Yejs&QlPdg@bf=!NfATBS%xSUjvd% z1Ha)3Ug5sz67sB@cUM5`)SW@goQ<1k^n5MR8;4S!!(@ zLNqaOTo!&w#~iSGrX~f^r9Am}pX6{qXI*=pbYgyeJwNjTWCdUgveFFA2coy^?2itk zfzn})Zl)ce2D2U8iw|;!!VPwIxyM$6Ku6j;>4o54i^?B90{M8A{fP*v1l;f7Yp|Qv zVswl-OL0t1tx+fDrG?Y1o2)ro<&xx6&mxRfGprO-8Pct<93*A(BAT=Bf9%F=>^VyJ z8AhBl)n2_T!EV%Ot^j-$7^Xa#YEZSG)+*m;OWLk!TdtcEZ`Wd~q`W^qw-cnHVY2CL z;l-~r;u6m3zPx-aiUd4&GEVQ{)~eIKP`I2Vp44PY#fk*4NRlcw^I*9aES(_wEmW=} zC$smFXo$5lE+CC-UgcuwTx#$K?{(DNgsCdLK7_-t^Lz*jeV|%&B8Asf9+q3ABN<~O z+9}VUY#3R()I=OL5?`abGX{e?%sSmh8YfI8>*&U6Nso--0HPVsG#~9uUBJ{^nGu_S zbGhPIWt)I+6nU1AM98w&=J;}Z$&`2X$3glOaQB7U&Gdrv9jMi!HUXZGasRVb>(*4{ z!$SU+&xQpBJWQa>5Gn<8tA@)Ji_)Me2M-uX zSHvn4)vd-t9o5`+L0t@$h*KAge)F77;9FeD=N6r<+_TP4h#{N5hz_b;IU z5UCcC9{eu89#nJJM3v+pkckTrL1S>s)EH>e)G6rF?pW;}u?Gpe$SVr{5vLQyZlPv- zxc;5#p?X)8A)lT-G`w0=33VM>C}7}Ud<|nSjwo3WF=Hj(?qoB@q`)ijuv@H4HdD`I znk3zeJc7SUKEM4=8SsD&nB3Zuq&Ovd>Ql^@kDGY0@vLLKM$J(eE?JX8JO36p?biTj zZwndapsR@DAfF%79hnj(ZHke*1_UJJ?QrCGv!O%L^BZ~+<1LwmNvsyWUC4hT5&LHo z;Cd&Wj`u+v>feBiG=WEN_Jp3UUPxDeH&i|j<*Xp;EA#KxE$SazPfUf~rT?{Vs=Qba z4f_mpG3I{%Rqsy2>VRwS@5$ywxhGuQjdR8P2%{9tUj`87698Zw8M7N&VwJe_g%^PX zCk*Q7%uHZZ`HsW|3iDw?fi|oCAg*+rZ2jwmh5Rf zGH=}z# z5;M4_Y8Vl9r2+s{v-1U&P`aRb{P0BZ;Em<0N$1&lTs_;ix|1fo3-;#jOWV7Lhffm{ ze9Y>6)Yq2h%oFb&XA8W$ z?+F$Fn)GsZ)%Ogvhpcas$5faz zX37_qSLvIPOU|0y%||x2nzNruAzJwOvI=s(uerl3CcbZqjwpuvq$Gs=bJW_ z5A0W&%#<~PW;+ozkS~i>l*~L|<)-H{j1>l*Zq(7H^_Y*Cip6v^-K-IOy^rqWLo-D8K_FNbuRUSxr^RY>&XO&S9e zWNCjc@Sc(d#&He~g22$UHLpTre9yreapX` zL?!zzbNu@c4?}@?r=}cq1HRI%>gxDHRW>&TJ*4$OX(bJ&dJMUeQ_;W@N~2_qh=f)= znbdm9LJrc4c$EUS(E=0zbMnI7>y9CilC&xYMMQefW)G@W9v^wVU=U|FL z8-^(Pq6Qb{*Q(lZ()Vv;Jq}Ge#SQgrR1H;bmQZ%TphmRR8wwBNAE_8TuEfi4TuHVV zaPZu{v>@46JKS7(Kx-imnUoUcK!ijGBlhB>wq>k+20_{BW_U(zwW224&R2FC$rnIf zhA10$jqYI`ia&G(2%xWZxVrMeVr-${@VfV}nDDy_^~<-ZL2NyVcHxfg0p{S0Tj%mo zj99x2lp%jaa;m4xV>XQPwkm5FLd1Y9SS${I*T&C->S8%#F1HAn$WKcnLk(W4C>*s& z&!TeTW}iAPA(h!=o;*%vDUJzC2xci1UNZz_eDWsiSjuOMhifIN?^b)TrrGuGqsMz>+Z!9UcmVjRQu6I zOFMxN@I1_SEVhH9!~ZxOvxWF*NPgr{a|$sYI19G2du5r>SSI_1oPc-TVR!|`Rw9kH z0D=`QE6?fL59ouPp5SMq)rz5hL3BN3%fRTC40u}FK}#=tfKEO*t(=}!%`pm@irP=j z51u~qq45P=gjMlp6$#%9HgN@iZ*Tz4s(lmonCC}7L@|c7TgkX}c5Mrt1kL8Wm%h5E z&KjRIuaEzR;{@^fLliJT{ue=Ho;u2~*AAwE&L1BiMwl&D9$#M*&ao{?AimGiE&Jt- zK7`fmN81VexPdt2@mpJtPAUVb>3~SwyJh-a>{t(rLVrjCjedYlxYWlj$1pW)G2tQw zzC$2;%K4k?vh6~^s2=l=HSAs@?&O6Y=9BZB6fX7+gt!%AO+qy51Oa?SxX_rf^F$0T zWJkyB+_jbXGZFd#Z7Z+vCUg34;Iq}9n3(gjU5dqJox;j)f^*Z;D2*;nOmJ3rb_YA? z&GrD&HGAJ?i9vz%5WVOSy>hC3wrc`jVxucx;TWz0EA8ly@HxSkpye^#-_j1wpS=Z% zf52UM`ebTSpE|d?Pe0?e+BF=mZE|1)VsKdTAyC@g!nL{r;_PNgj)OGFiz5RdT{?ow zz=_6UaWbnEcOxWM;-%Zo@%kxQctzEQh8L;W26U}!@Cj`|U&!{gA2CA@Ky;&Zy<#W= z3R8`++qRc&eB|5G6@E?r(b=HbB6H5PXk+fu$~K_|U5#RmcluLc{P(ZLtrf&`3N&e( zx(D>?NF4xWstwht!v&(0ciY}MxdtFL+pMB4oHXL13`Sx8#=Fl5Xb{uE9Pdazm zpa0&yf975Tn)RFVP>uTVs_gmwSPPN;0pVo}33`h|>n2-@aQiv=2?S_FC}6=S!qa0Q z7Z&0EtaRB-Bye*4(IAa`L;MAwsDn0K4h965NM=E{nTS#FTQ>4PNkQNt49biT;WmQH z$b{94|BJGB46ZDS)^^jeZM$RJb~;W69oz2M$&PJ%2OZnCZQC|)PMuSA>zwc2I`#eA ztM-qzYSpSS=N#|*KBJx1m%-I4z04JuC?_$&)bBC-DkX+9GnbAkU8q9MZa_Y#MOkb0 zOogzdY1kHzbD=hPcI!2O?RB#s3dGjbF*&9iRMGyL)c6uA?F52KM9J*RlF}uU6WxTW^t20 zc399ir_UB!mCOZu`TRL(W>`O!BRA%xxvq#hWIp3;jyYseCL547p46MH|M4~I^V{L= zi}i>vfluD-FVtBZPN6Z-%6dJO=?Ds&FD$X__%M>?K)#S&RNAuNSFQS}#8D)y5Z$If z8Ve0iLu>yckK)#N6Fy!ixx6;AR)Xa_jiIodrKqggTQ_gfL62_v6OWT1$d-9SMZ~(0 z*I5UJFz_MpS6rYlR6`xL>}-s=K5QSUBwUOkgcC*S?X$kG;E8&}gPqTEBR`e;8GQl> zh1DaU)3RMw!6o)2c56IS31Agp!LFEzlIwbCPLn^+RyI69=QQz#az|v)vOKN^Q@aG* zq&+AFhhw7cJg6WyGRf`FAdYq14LQfia%5^G2g(jc{=|>w$lo{VkxMs#NX~&{x=Cp_ z*+KXA2}LETtVn|6xEn-<;pR|T)Xk)u?AWWZXAq*%Wj}QsqOcO8z1m2HYiiLkuXGTM zD6)@l`s=z9OQM*_gz@R3WWhj_ki&#CJ6V46L7b$Gix~U&uvps&v(uklxMsVJq0KkD zyFBYK#mKq=O!_*~?s7O+V?gCc=O`68dq*X1Pa0Xtj{-6NY&B&zjkE26mWFYB4j!WT zwu*#QJ6)PtJ|20B9XduuC5v$SlbV})i4ECyV(c=rDCdXJP~4g~g;HSl`63G-p8|HJ zhSZt2mMn@UP2eHX{AW6K*`3G0`X*OjH)KzDc0M+hn>UxF5UclUd2SUAmiPTM1ymo} zVR>b~$UO?~o0KHKU-kprTR^AxAMzzYZ&Qzm>o#n#4|oRP4VK3D#}=dMH~9qItVzi+ zLXKPH{yxISi_y!AsFw{%!*<$_vKv3l9v%gEjJ%?OYQ*%l0&w;t&q-S2rvX3q2oz{B zf0HqsO@V}PG{h{NeFljojFL1GoSx(hz8C)vwbV`qx7!alb1rZsL2$v}$lD=GeGA-* zRyHMss%vuMw~P5L4Ln+CxgGkxWW@HGnYQHo4GI|}W>Vos9uWD|Zg$hlHipzF9s;I= zjV0HsHDvC%C~;xB=jSuOkH5{0grzlWgiS}D_gkax^|S7fsJ;g%9gTa`YiC6JfeDep zzM>~b*Uff8S9$fn`^}$WSo+vTUp4mF>8$Eq;IM&;0#V_#=&>?m-UY-CM^e7omS>=t z*AXQLDRPP=v~rb$hRflIpfw;-Zt2J0&2#nq2xnWgTblUf4nJ#6n=ws(*?$wj&5JiE z6qq#%XFCk=i|$E$1BSb0M=G}9QN0>_*a%z9!kt_E-u)2h1gD@G+8G)Xb;-ArL~Pit z28OlWf2!>XC3&Qk=_1|gzY1Onlc)6bN(ve z5C~JoWr^>s%aj**t}}RKVVmia+SbeeZqE>Z;YPjFaNOF>OjhM3=t&ZNAv%2WLrVF^ ze(7fy2O~?scrw1qErvLjBN<@*opTRxX3r^zi*U0UBy1JIJj=`UW-}w2S{ZVBbm92= zk*EqUrQt}V>oNOaI9Aj})#@_xO3PCMbKY<_V}MmH$)ubb+Tnz{<4%P_h!?x|m(R}| z=tUS4SI%tZ7Apgc=Q$=8E+?NwEU4>$V*KyRP7xgRis`pVv-5p?`QP)~|Gl66en9Q0x9#E@ z>^U#eOhXYxH`)5{;dsmYWLh2T+uhO=5lG`T69D^?N-{qSkKjy*iLS|6+D@Jf^n#$S4rqrCV6kBVw zmD9w>S{5gq+NWUgX%e5kO99u6^bwC*>A5zTHkyL-N=d|BH3Uw%$N&z8Sxxya;bOtE zvI7y4sm;vE|ITIKw?08aAe>7oD9OFI%@1HdZXKGV5H zZ0WRSYVF2jlR2yltq&`?U`#0SM1+=@;@kARChICFXLZUP1*6p==0`}JJ?8sk>_7qK zS!|3ro=svHMtGHVFT zU@wO}9309B8X`%F6e$`1r&h+S)VqlXSaZDjFd6fvc%bPC+GG|fOP3E4YIYBRpKj;a zexgTQkS?^qhzF{v9yyw{-KN;VifwDqJza%-;CQG*gzp8c3#a#g2r}jM0?eu3T|=C2 zWc~k6x%@vq;Qx2mq%QwWxkTr;YduPk=roQEqWXcVFOh118pahQ1dU=0N)t+X^A892 z*!Vcl1NWbOR?=5D%~-G+B_5V^5{ZxM0aUYW%Xh+_K}W07P;=LPBg=p|XmmS&%loOr zb&B8n%6;x`u1jzo${u%2X@2hk8E4}BBbhzAmbyTwa-(sci}9Dg&hPutN=8_~%z zwW^0#BlPCF&7d9Y8~dAnHh7q5wA`vveQtP=h01=F)1>>Td~r-s_-78&HSX) zt45LOHd?b@rgUY%D$|sYwKPSY@#IVgLrT;CIJ3p@WD;Nl9jO+`$|snWr8gXXe>Dil z{m-+T`Be>Ik3TH%pr#lQx7lF+r%G4vu(j z?oH4`Kv(Bpg{LBUT;ZirM&T+^XqisFyn;8Q(pQ`~l@Yu3!sA?lT(2H~qh90TFngW- z1C3v8x&lK`TOBeq|9lZmTTGW>70ts(Eq4QH!+u=E(!I}-x_D69(`cevhXgtS=_Cji z(6GxyS=d$#9!-Ef=BbZoWo)iRD`%k*Z8Ms&;OrtOlLcjf@Kp1MY=x;3Ak3b_7hCVE zp&V03&HIz~bX~oMuTjI%x)U{tYNW}dfA-ry{LwDAQGbll(RsE*! zPaCWpG-zulTI9hnre7k{wzAosS1YyvB^U5yIl;hPpgCEA;xBT${K^15hL&La+rMeL z_`Dq=esK|LU>0n zwq=E)Nb(nRbt}X}v_gVb{e&A(MDM3cCm6O+4s8rQr?%B38WqDuGa)EaZh0ej*^Ngy zd$SA#e&}|wO|qz$#?F;|>2AI_b!KYiS)+06TY4w{)|ab>9wK56F0Q(JFp}fB{Ovw| zrNdMc-1;4Kzs}9K==qtBd4ESMa19~X{79NzY_l(S(6vnYX+J;LSg<4b-dK~4T z?`n7at&s@-U!D^Ge=t$n3V4#}pM%*tdbQvQ=*8gXU?lqIxV*9PkYF&(oLEq+B3YCt zHVz!7b0%07OL4PDd=EsbWv_~*6S73gr6e6vFF(95b4pc{vR5{qMM5diNT$Zq((baZ zGVh`$^u9iB@VhD2qjK?Hs0=kC4PnMe%EfwWXd2-RA3B$H(L|NtIs2;_08wb)2LXwb zO-T}KK=r`%gAlu=R?m#}LXCB;Y(=9oll;Uao@GOs8jhp*Sf%lNxJ{ZR&>9Dz{?~b| z+?1p7YR>VS-L`N#iQr;a2thl9yfRMoXg`^ednE7hcP z`obg7_vfg=x>*JGX3-q!NmuL-kB@~msIv`^I_|rt?*30=rD}2E}Qw2`80e^ z-N+mDmVY(17lW@~qb*m0{FLk=?P!ks`*+H#(MYNnr zU6!wWTt9{OKTAaZJ*=u8`BMK3eni{69bctqy{qXjDTAEyw6@btj|nEP@B+z>)dD_~ z9+N5e0ba%((vQV~Y!_YxYsHA~2Uc_#%jhr#@cqgfT5Oa3O&Z6+hWG%zWf_ZIWddv+mil@?9 zy7;K{lEgP~p|{Na?x<$&Wnrg&3TmYJxEw+tAN%|(mzm=@A`TB3cw^mjsG#^$D}6~$!L^XMcMSelqrhp@LkvI(r!w=#Ul7wjWnh;MU zcnqdT#>A{w{4P|*BJ@JvQdO66*fewZKT6!fxy83K`3<@JZifBeiYfnJOewXsUueSE zpTLdAdYxQi!yYgi4A0m`RX%;Z_|<-?@)G}hP)6t0$cx>-Dd+yfyzY5n0XMx+*Ljg& z=a>lfoHiW1cSK!ZY;|vMQ&V~%i%Jn>{??$<`>0|EXjI$Th3XV)iQ(~oMjbUH@=*Ie zuorRiZGXG6m;e@lCayB=M%t8&7Rd(C6AScn)E$;Y$eJ*XN9!k@`ypzM_-PORj+V1*O{I%)Wff!zm~M0Y11*Y>39jxBS+%GFwc>URvPuKFhd?)5N!5Ocs)p z*Bg9x(DgogL}v=<7H1ueT+-2atSLzjZDulLsB>xkhTVS^2Up6C(0%?KPY+P-xM=2B zTK^*O;8efFawroX&Hjg1#HuN;rJNi_FjmKYBbQR4g$=2lI7vgvTx5t#je%5+-Y1F? zbFDD|nXJYqtTuo^SNg3m(byWL85o@#u*^%`5S*``>$kw85ji^vVhb67yPYC0vF&iB zHLz^d6qD&DHTC_Hz5O=b+Hkiz8>ilm6AG?B!uMT)_R0L6wiqt$!`(0Tt3=VDp*RxV zii5skBiAwu^$bMj7h=(SMoebRB)v~sW-_&iibv^XZ5F%t(g$$=`Qatg%Ul?yUX)d( zottHV@_R(9_e%K2CE^7w=x&P&v_mi#8Bb~R_b=p+TShGr3FzXyAguS$AE$Bq+r!?Aj#XuL5Tht&wP~lSq~)kH#OVCWK?g6 z>hB*62#`Uj0q;tg!zRCFPD&Z25%_0#eTUjT`>ITgv}aCT!4x^HN!I|C)SA zs-zox{!xpbvau!K3fHzB-_ZZHApv>pCwa*UwvhHdb?1-Rd-xI^*uRU{s*W3 z>q%g@4NK20ER;q(C*l0QP4$n!PO-wv38tTyFDxr0!0XTqJ;&$xGjx^UkQ^ZM zNIP2`Bd~ZzhM7!$938^KFgbN1g*%-}uAs$`LGSS9{iWS3juMk=gtq-%xjYQ@XVNKS zQM$%)q2ta$iwUAqWtjM{(2E1vV9H9zSybpCS&A6C!?8a;6}!dmUTG6mvTQYpFKL6$ z$;<xJnt6$q_vA<@TXTe6ARJr&;ytZ03gSjOP1exWdtcifoR#3q%9{ z)E@dW8T$MN3iXlUy3?-2l&^)H~uK19Jx*BY(xrN`ATIHSGe z#dJ$oPjedUl%WmyVH&Cd_QMqqRGlM)Y{R7UQtErxaK=P(%nDRLZgT1D)WP%W2OeR?0I&L%q=x14#G8( z(GcNs&C*oo(%#t`0-|s+_58^e(n{fn<-TNl4`j#3wwVR0meB$7z7SC~0|F|TUtE<9 zyA*6FyEsodk5!t#qGbQo+1(JbJlxBZ=5^Gwt1y9ndr6og7a$y zX0A&xSyU(Dxxm_Tt{^USvdcqAp-s{P6qnrN(=!=6ogZ|yH#S*-sjdM`J=V>WP`FTu z_H@A5R3-g43vSkw-Ju~jo|eftZK}K|3ZyYRY8+8kNCVKISy~+^&Chn4+p^bnk{9@} zv3F*|8KZ~8SjFAdi0y@r*LfJ0WAFkDdkDCVV0g)TDWlP1s)Ci1tA;y-&|B2;P%aicj(J_m$QwpM zXzF!enJq@wEQk<*4L|X*;wLLHeV>h@gJdtN+NkFo6L|RW*Dt>B0ECh0+Xm*N6p?mc zU!6Qb7!Z-tp=BV|kaPAVOR^xsO62xX;heqe&Wy!p{a`xW7H8gXO zl1F|=^y^0wX zDGH;FbuRF+@+Kho?Ck8ly>%2m5Z|Nea`QCtb&nh-rBoLD zMJoO86I)xYCIyzV%iL?f-fuX3s`?@RZ?< z@P?wIj(wfzY=!Sf z^l`o}Pj`y;bFC!W1VfE*ee&yTx6j`Q;`APJ6|el4UnMb(J)m|hF7pwgh|IS65%n*OluuOtPA1J zHnB37Jetlll#K}mVXO{`DzeZ4gE5hI@QGQY^kauGWLkmoCq@#tp<@pJ3R^v78}<3E z=B~aitNjMTt{ZZniI_a)uVbAw@}-^P?Y@ez}=t{MqugD|4& z77@7=d-Va!qpLUN_})IOAGKK^W$(*R%lR!S%dDnaO9nqM`?^50gxXgep9?TYvfY*8 zM-c=j#mx~E&rGzXmZ0)^vMhAWue4%EH~??c=2s7P@K<+|l_#t1jODI=!}OZW5-w>< z%JSj4&9Gwc^gGB$Vgj$rXGj$ZYKQMN54CHR%MZBX=CjyYI7XIgzpi4qM|he8o6TPh6JMhN=GxBt?j4-*b~#}Yu!StT8zwW zHa<(vp$XiWMx$;_WvB_tnyDg!LE{I;87;AO_J%C4*0}%`9VRCjzhqIV4|IU%;CkCX z-L{nxQ8TcbtWdS3*4c>;J<_HwjrUj0F;_~{roEMDam`@9mw7s%xa!+;4ggM^#>3^6Izj?5zL^}u*)*;Gk9l*b|0-m!3Whl8Tt;PsA0A5L;j zr_2IIswCnV89`zb>sNussICf~I3vVvNVU|5!IrAk9xlLSluxj0W>{4ZDwIc|!zDP$ zQ`!|y;mB3?W_7K!ZvpR*Dr^sW^2+3NshM_-cQ1M78MN$u>BnoSjwtyKKBPWFl+tvv)WQ`C|$P*B=2al9t*5)+D$`grm zY!JV>w*<#G##3+p3L)XSsz$;877cXmZm3a36TMmd&pgRr@V%2QP=E1!D}SEWWW_ac zm$t6ER}4-mdVU7Hmk$HQ7PpuZo}weNmS#FP$nt4E>Fa7`R1W`6C&Mci8ut=oj$p^f z-Gk1-*hVT0Wo(mpnBG-lE()pN`BJ~>NF?*#%WpoTxlqHRdIQgW^`X(q6y8zl(|hr6 zJl?JeZytf3Kie|{!vYq5&ulQ=qEBmpq%|3(aI+Jp03&r z(bOTHa_){T>JvSh7y3luM+Ix_74N(VW8dv$Pm~@6PZe2Wr+@QZ3hIb_D-~t@8$9_- zSdFrfH&VSLRBUGCLS$vQ&R;2Kn`Ns6v87)J^~s;mcWhymga}VK$EVI$tS6gDt&z{x z$|1rcbH_ir`EQY)(R6aX+6!9{FuWjqk*THI64zhRDlUdi80fxhXn@9JMt363>jL$bgz3N;m7F}?~fh9P+tos4CjxgE)E zz}{bj@k*7}wq4BSpy>Kn;R^+elIHan_kE+Lq;|v*~mA1+kBEok~6%b1P z`-%Z6yP!f@DHuR32nZGISyLcc73`hdDk8m)Juqkccg$Z_lrzWkN-^70 zg?uR}l>dPYbFUNn92ZmoH#^^Js_}$4o~aN6lB!y+M^Yga2-HI07qy(zdc*};%}pzq zy_$`!B}(#13FPvX(;AaoHPn!W-|WD2J4&#@#;eAFUhFjZfn`x?i$Z#2H2Mra1|iaI z1b|&%j+Aejfiuf!B`Ny#JtWNph^4-wI=E@$830=}hqG+vUXOa>gVA}aAuE~N#H)tLeb5Po zjs%Z$T?!u%ub4}I&cq>Zo2**}ttF8JIE&6a5%0fVz}H7`g`>jsT-ag;9bavR=@w!> zsDtx|avg8eJKc0s$BJJ6)(B#pJR04Q!vwD1Ov!xY7sTM=O6px=eH}I$gy~=YUq2(e ztpkbwz*m^Mr_|NcTPA72Y7hHHVz#JpK-y6|DzWF+esIat4@RtN?mR4`{GL)2h9yt} z#FQ|FaT;9@x0A~ZQ_74`k5cK;1yHCe#+3wN&;c+Kdtj4gI+vssMiO`$`u>)g3z=rq zEiZ&#{?2ICllPU|O5Cgq=nSrcZLikSim3D?2wpISKX_3v5&*k0pdBV{s}C@fkjs5` zB?dx`n=#+CpxF7-o|*^)VoiE(_KQL^41@*y_F0WoZDLXMf(pk-_Z4CT?r-&{sZ3}i zrl#rq>DaWV0r9MClEjtcy`p)!zs+qUn(pBzL?avlhj6(0`Sf6YSLCY)TG--fNfG}} zXlgd;>dizRtH>4{;!D|ZDhdS)?C>H7O%c-T9y96y@Yr)wEkX=Yzq~>D&$_b)iy5xV zu>}fc!uUZS>$ky8+@|7PX=@#Bi0QZUGq{#7Q^b{|cWI^lo}m z);^8(LmH^27{)8pLEiVp|6aLC(*LCD}0&&_;A6r-Y>C)CtiXk zt->f$oGZ8xF^wZ3(?Hor5GH<%UI1MYPAh^TFv>BzrH*`XzeLnWRV70Zr#w`$O3BxV z_QzaTo3wy%h?_tHVMfstbO4b2gx+$ueyVc&B2CkOm%vs)K4oM_KO#C~VAVi+rfvlV zh#By5MtG*U0jYk2t@eza9U$Asl(cAdL*M*lcYE6FzQL;(1(LU4gS z_~Af3?-MtR5Lpbm_kDo-Ia?oNfm=Mjq)2||aL1WDI8#7yQVz=Q`Kb1DN}1xVXV-Mu zctKOE_5q!KqTM7k*`{0QAsO|L6`+K}i5t+&(Zi2-rG2g8nm8-Vg0$0zT*0LoANFaW zY5Ic!+N&xf)uW{zJ#cua*zW|6N^nxS(hWuU4kMB1NI#-VIl(PTYruW1N3_j<-1z?M zNNF3+`OD=Vi|P(Tmc@coaoWs#DKy|DarZrvH>Yd%xC+bg+S7EGE6PO9r?lxA-0L)L z*Qx%NYDGDl+9z1u@xV%yOOHbFVjndB6&2??q+};f3C9$-E#g@~?tnh@5iFhDM=EXC zCUuM#lQ}sZRyVvhYhxs;^TG~gvBHp!y??sPd+V6;PoZTr+#mK%YP4DH6Ww#^>3TX4Lp2~yn%E4p)0u~Du8%)bUM$^Jmp4$yYb!%vZ z8x3VBR}$%DRBEXu{T*mp>J@LMNhxxYX<73&KwGua+O%tMr=E=KuI)eq+gi=e}) zTJlLZg*~6X@ z1yO65_Ax;tQ0ADs7B^$w$d>~m<_>KKb)suWZ zIC>9x*16Yd24F%$!?$LssDRbsGvk9I#fH_Tw~U(-7VZ{h-g|{S%Glg5oKAs9mV4&I z0uzm_SBqx*k;{m0^t{UlBv2#8Z6@@2*Npd&S;bL-U+H{nl?N|F=8KwIZ3|LQD`$X` zFsChKohUh<@Wrn4iM9mKjf^fXDb3AytWx*bd5tu3ryR#n)dO`$s-_vf112>p$r7!W zzW6swxj3sxCk%{%sVNgPY_!fn$1<~bkXQ)WNN6`nvxcif{j0v%8 zOiGSA(k)hL*xXPbcpsz0za?Of?nWs_KGH`FZr<*N;|EShnCU;K*IP!PJ4Q^z(rp4$ z%(_ixpIu*L#Iz6U`Vx;4DhX>A^zeWN#WBllLPvs1S>Nnj96Z=B@h*Y^@EmyZ5E2}; z^LT0i+$ZNpOuKJnXkY2H@Ik5*LVBR`dey*2#2e*0t%KcwH|yon&L-dubG>TF``_qW zMd8s!=@;C87e*9|0`^+zU74W zofdmEO<+4oMwfvL788Qqhl)>DhPA<^ZV+O#=}DZ&OtekNGA7xm7y$+{KKDk(2=H)? zQqj2J5B>;IhJbPg-2C{$`1;`uGS$&0udQW9%J_7|y~TaRyS1^uau*Ww1K`%=sf49O@EEmu zT7oRp$KnY`l1j``VBVmUX=&j>vjv3!hf`Xz*}M#Mf#%14TyCzqvIzN~99eQ&VM3NW z+=JLf1e_ zJBury39OV#0va2b1=F>o*M4K^8+x@1x|f2Vi2Oa@UI&OEwGdB=bzuxY;dGs^vl5`6s6&P2`2uv>|iu*NI59l{t5R z2Rb;4@-;3b#(DQIMg|%;A|fjDJ`RW!rV60}zkt7;8gV}EK7?P=+HC!V*_vqnV~!yHmZmjU?vzelO#6%?d zkHyl{$1E^j?VbOA#vln>4%9^OJ}#X#?|7QyN}I5h&djCM2AcuEj}#I zBlRYe{9>MUMY8xD+-rVE%b*wVsHr2m=IX-Wk+mhCl^@w2nh5L7=Ipc4F^Y^kY zW)u;dFRQP#MEd9HcsQ7!?e&E{!!Jgs|E%7wZlVV3?MKaSH7eq?R^Cb{TtpjmzVSrg zySzEegwf2gx0Il$ZqS;p`)th+SdTFs)e+Jc_?0VkYkb}|ef^+_moHv6#B*g^VKA1j zxM+lVC?H@i;yR43z!gRr)8cW)4sMwZH!U2KBakDx?=R4Rkyf9GmUNV%AS1~>aS`T` z1X2^nOap?foMtq9^@Q7`f!H4#QJLF@E1EM@a?+9!ab}c4rojT+Nv7dq&v=X4+@60( zfU%XlbS0`UA8G^iEVS>Hcp{T#(*NyOlogVoF;PU2HN(a)5vaw?>sVCZSj6>au%-ST z+g@5mp}!lY4n}=GwXlsA1l9>)Yt$mugJ}3QSVNhg73A+ApKXj3?-n{RYkc^{b)6;} zr78A&&bs8wgHtol(4+gP>DlE{qLWC=6`e>qnF;`N+h^R3yzPbp$8t4+^&?wXxRvwm z(`#`PTV83lVfT2Awzo@{rHJnrBhX6;ipW>$5Ko>K;0?*x<`41)y0)AGU7NAo*D3O| zEtv2T;dP}6+ptOcCtP8|6?2bIH~NM`9g+Be^k@gv+q6Piti`%G4R)?apK4A8dfE7n z5#A(sI4r4r_8+Cpf(>I6&ra#=M(<|RuJRI){ca~~toYMcs7p2DY~+p|eh(Q%KH~r` z#|Vyv& zq*G?Yb57C|R}V#nutGs_oc34{_f_%6*`G&+RPnc(6fmFG*8iH3B@L6#jjL@LH|C}S z3tFjr_o00@y(@#Q7`u|p{&h-!u5ylC89V4t=rsQwGFpT06gPjg#4hglO2-|oI97oB z5WMI<^!*>B54pUFk(kgxKx}A1KxqCqrR=|I`+pYm0Zq?8e-^U7vUpt&e*tz-;(q}A zgUG=RAVEpu$b@Ek$)CfTn46 zK5I;-U2ChdIFZJ7uv%6jSwS3{4)>^`3TBACD!qn#NU?}D z8U886MM}vOS|A=?((+9*KVHp7n{8w`8vdkxXa+qRkT4NooutM;UC53ZAkuQNQ?kj; zQm+@|3iTxE42jDm;Sq4dBt1{M{`KQhDe(_x<7nPUeNu%0EyR78)Y(q7d-?p zg5jUX#YcP$PLKp&p{dsQ9l+~GW0u|pn{Ax( z`NIMb5El3hFDd$JU>#o>yO9L{NN^5~m;uW}!#vS;+dI?QOel9uomZFticrcZ`G+W| zHGoadE`{v3G7)aFQmhbzh(w&KXpN|shpJ#^Vt7-H;brGCG8ct5RG@)dyJht#>3e8{~%xl3amBc{9|nRQt(nsx|4eqCd&Gn6n$)jZXh{Y*up_`)s_l%+ZHoyuMLi zFDF;+Zf(YxUr&??48&f;SQ0fLH`WQL)pxs9nT~H6fp}rjoNQ1RM+#n?#|5M5}eh?E48V6rZ3>lmSy zpG@Rp`wE-o=V;iF5&fNiIo&Xf(l`Ug%!2H3?_**`K+2apsW5)9mNjaZ7i*JLEN=s~ z&9Pf;!v^B5t9KCjxv}9W90~H7V*pMU^`rD0;gp;o1REE?)XZLg&e>{8;$Dfx)|6Q7 zrS_QqQOK8gZMHe@faEEVG714dzc9+VYONKlNC~46mdPR$=8=CjV>nvS=+7!ONHgJyW?cttr}uc@+U!Dcy!lZldJ{1L(rCAq zP9IWS(QWdHH_{Zn)H?1!wmRcW2|ZIQKp<3Kp9eaDul&JyD@WbDJSLm1%G#mUqp{%< zYZ^E_?ciPynWD-CQk`Q`5)O+gq<2q0VN6u@xaC2SniO3G>jQI%36)jWZ9Y?jc}C=) zU6z_GPf-3J@iuq1zqX1DXw$5+#Fx;{8!Seu&!j+I3D5_L!3>?*KjD*Y$CxOtf+&(I zoYL|Sb=pmNK0u+DZPi`2@Pl2GwGCq^SJw?gj#J|UdS^sy0zGUz?ah6uLNl??Q*Qb> zd-CQ}DF60StQpk=l1b%H71eR#V4pa9GU0|FhdBm1?#cbmup!gy+S8Wx=#7uAR|1A42BcR?(ivL~DOmu7c2%t7F{(Tjv|vQRy$R&X`D)#b;GwFa+x{d#v2fIf!P+wW?Z{wSnK4M#pP*;+f`ukj?encP3NP7+2wrW zSX|fUoxQ6AMu+gX%`c9004}re{RGhw>Tx~o&<_#LA|w(uPD!KwZ!V;(61XkRApmTz z-aJN32*Cz6a&|Y~;g;=A%;KX@)n4!=k~taHq2xl08ag~ZMxmYb2u$a5Q&LLlsV9l4 z$G7FlU<%uvdE7Vr_IaSLxI}{_$w8@zFe)+dsAGChz-{(pdXI~5ho}TI>eBL+W|0WA z5Q!{;FQA+$T#gCgUF$S0EFri@V1 zyWnu4u;oK{!Z`raENaN&S?E%!_?k=B*4myh#|@!Qx8kfs6hFspUC+oAT67FDSK;2q z%RA)u*mL-OtGMW%&!!NoG|310tv#syljYkndpmSj-7}RtH$?$EF6+#N|y`{53d{+Y0+HQlER}X9<8UN`Nj%0`5iu z{6DG_nvq9tOdi1C3q_{Hz{0cHaf zBsJ@ZGV~CjAGoaVUa^4mBj~m#QR}w&7c>ItgJ(ijSiGEN@#}zc4MK~~zr?|S=&~7j z8kJyCqOoz*b`u1TNL%rv@g6-f)+AHXfpx`q-f>2pYt28+n;P01;glSg5`dKJb7zmL z-6m;*HSw_Q{S-HJq;!?A=UIxq=V{^45L4PFSIuuZcM}FhFL#!Q(bM^Nhdjkzsqvdr zI-FNT8Z%0)5OuA{i)xTUHMp@TNrYUKOtuK}kdX&Q);=ZTM)c7#KNkJU7iJ$5X3s&> z;~ex!w%p^;db~*4rB*nR zX{Z{2Z;K!XaS##FUClCqZUP*B$$g2iXek^ogKX0H{0P!S&^n|6rv)1v`d}$8mI<&- z3c{M@^MHZMEuknb37mXTrCFTSnh`=U1k)i+pH+5?2)2v(9xjvUOV*Cni&%gpe_G*gR;%q)b*#use|&IGy8I5am_?_4+pQj zB`>vRM%td9)*=yG+p>tjj;$tha9Ul9tZdP;*Pxtp0;NapGofn5X1x=fS*CXC-^wVl zAC!W>ns9VL2>LSQ6;ZgvlLC0k6qJ&L?36-($jB9UnI?j|IxYwb+>F()(*H|amJBu& zY6BA5|5dLRCA7tm?aOC9wiPYbHatKjNIV-f-S_Po+b3f^7a# zTwLXV&`+C8uR|z9IDvsV#ZFpqJAa5mtP=emqTYYy5;;41Ny9=f` z#TsoG3^9?n(#^Di_5jzcRu*{WFL)B?R?pL$Y}i7z8abRbntZG z-lU!VMD4!)_SD|0$!~|=90T?=cimnE_U7QWx%btTeYCrkDX*rG@eK%T9AUguGK)%! zX=i64VlSikQRNY?PU}1e+(YZ4O3RMR4hm3Es&NCThnw~6aLcwB`ile+@x|y&jeX3IhHts)c#*ob8++c7!BKh8A(v6ZbAZrV{ID9B( zipw9gtvu!3v%Ksy%65Pz!>=HRF>@($npeB|L9QL=Aj@-;o1!abC3&2_8`u@Tk!IGP zBSR|=tJ_0~EJbWM9M2fI6~C2me8A>9e*GJ;n=7nrS}!By?3hL`J)_6kZIH$i8KGf= z_+$Zow|K?_ULcc~?<(1=^e_C|k)o9M2dC+hdr1dNInT4IurdxS@PaYohv{Spb{cBJ(F#B9fC9 z*5*bQZ1IMLl zD%+=EDwE@Y#4oDHS#aO>|FHIzL6t4ZxIyWbVv4cjmr`cOMyh!K#S;C;2M#tF$r>(wy91H;h|nKjt4^S5zCh(``w%oW2=1 z{)MbnIwfbcT?}jfN`_Ka%dOJbo5)!#W>&N(PFf-FOwe$i?KEONYK)0_DQfg7(|`0( z&8@rpDRF#Z*5J0e9kC+EW+;&xW%{Hd#JJR^u(b_3o^YzJ(`w$A^jiJVhuVbcBCr0A zKlNEqecUtkfs2$IAd_-xUbF!gueR(JzN~jMdn*|1A&X zyao=x8{$(#172Vc_S(N#{Oyc%hNUWy83r^f&nMx+X4ZLI!Vkn_>5$=ZdM_7A1&LM) z-MO0ut4k$-P89Cz8|YtiDm`edn;ReTHdSCCppPPTARBuVT0Ikc8*4pU0~ z8*2yJKeH&-j*2z_Yex|$>)+S^2*6oMOG$jnj|mv=(fiPI=&e9_onKo zvEMhSmoJDErCqlZMI<%er>~eoy2&YVYpf|Rw)wSbh0&=6v6wS9Nn=ZUwBD9{j@_?V z90vDUK7u5Tu8_I!=UN`9OmBJMAv)iO-8xNrh>pl`O@16(8OjMqu;_O});`)yUp{9# zevb<{+Av`R(fdYYDz?-sdnq;rl#=~pw5GGdKr-LB)(*(?ZzEh#F`zzVzwG-$J_p$6NZ7k7gfC$p3NXqms3ijiH&b*>3})1^)|r%4S9` zMDj*X4!DbV z;oS7OYP0U~6H@3lJYH8YL*_E-XDi~I*g{5=eb1YW(R9W?8h-}piwOLJwU}Varm`i> zi2R_3iqZR%;|B;`1E5+wvAdDDlrAOtKPHL^9;DIWYbr0bzmuFj~P7>%;B>o80!By$V0YI*js7}aK6 zfc;?}wl?iOjgYl_1?XjHCl3lW#5zzA4w9YFCd6xl4kAXS&?xIsOB4%I?WVD-8^U=v zv|=P$HwvK%3!`*_>(!gur;=b}k87*M?;BfQ$1o)-ctj-4SX$?C%(r!Z8{X4bHuh=` z#4+-3gVrB3fFx0%L@wH+-5yrFJD0RhxN9m)>k~P&Wf0b6;_N{I9Ys3T?9nm}KCEw6 z)TV$+`fM2>e(He5Jaf9o9*DX0H99D@Znah=%)6>s!nvP3wEZh|_WQ218kR*^@4T(|gg|nC^e?Dw4kX5d`!J2ngk4J~iuqwn6`SL;Yd5 zD-tvmX8ArQd8~30j|fwd;b&)C@ypZX&Zzebn4nWm067l~)(2pc5J|^w?-4$3qg?@; zbe%-tb;0ksvV@xD6o_vb)p^{fZ#-SFr|m9YT<`*q?Z`poB0PN$%SB?;8x#4`h21pf zvJHp&cx@e@_|VggH$Wix(5lH?5KB>|Ui($8wHv?OJk@enahS;{?rW|q=P1~Eafp2X z6f=P8q?96wT6j_Ns->~ahJ5ui#2%N2T#QaM-a!!t2TObyiJFq2FxXCIpmm0 z-C0<;tpHh(X=KXLY6P2-5_WDmL&)7*Y6>M4{^{L@V`~5l%To=8JG8r+e0Z#$$}lr{ zdD7>S3{Ee-+1Cis5F4Fe1%;~@NO}&`(dP+m!Z>Ff$s?Sx+tH-T7}r;QPiq4W&U_W; zx)I+R{O7EM3hdQb#;;No!}Pd+iufbGH_!iIEm2QZ%iJGUo5gN9l40x@HjzoF4|^=H z7t}aPAZfJ3(JwJn4^nJA_Bd|WnuhH#kKb$WsahHu4l87r>@w;Dz1@!e1}uBKQ}>V+ z#{fc;OBn$HQn?fKjSAO(l&yEH1c?r&fuqUGE&RSHJF-$%SEp`ZPCav*+Ghj2{i>fW zsR`O((}$o-#ww4%-0C5q|5LNTO_|{nA1@6rH$+B zABuYp^uvpD1JDdQC}$h%K8rr~MwndBA)1=oczwV`vjmo(1sVzB{s#03!yN7)d7!#?`-MbQ4uWRm~-)<1^A3)=i+ ziQnE{&rQzB$jRu>y{Ky8h}DnsHjr3fTOS%~u*(L23Yt3P9O4TqX}KumY)9HB7a*#Uogd8y0FlP$%cl04dWhqZo;<3`lJ$jq|%`*XwYa+|va>wHJiNoRz+~>z|2pqX9K?tefBWkApmY%i)QApkz zPsL^meqoD;WVapIWKcEmBsp8orW+V7WB^i4=FhFS%1T!g0X|D4Rn&_pSVwD|^YaKR zobwPTN0-)FJ@PahYBRjk<6~^}C|H=jprDUTpS1iGp)Bsj`H?t`%N;z-Ag6u@5iCgq zfZ9w|0mL`v^{_Y-Mb+KwB67vLg1*9N0P{uEdM-{moKI~HebiK$rwsbBQpPcsY|7ja zrYv$`IkitW3e^_WqHh8XArrf zx-e!M31EyHGpTbQFpr4bEiX^3=g^d+N}DgNoH%jIu%sP6X5G6>FDT;BgePzqmz0`F zUGYR^Q6KJSVL+adCuh*#XH4WXtB;!CA3sLgx2~!d1xcME!%e9H!QaTQyg)3DSU?Fc z=2a){RTW1Cort8-RB*w`NQ=;kIV-Tg$!#tmcDXZ)iz@Ra3w6`!0tY~S%|0~q5-=&} zzy3*(jO?n15KvFA_gys^)LCHkjNomWpm(M&)d&%dpl<3WF~<7TZr9L7csg`Bn>>-6 zaM*etr9gp6T}acjWQu49ajwEjiiuWp26bSJ0*C)U06Ww zPrV+ASWqt{Yq4uCdUM3&|Cke|GA(mU``xGwW0G``^Q`^eQv1|;AqA46F;AyIdg;2= zZ?9XDhL_#UxWw~b#{PIlTP4&FuWX7=KuF~ZX{~&_sC>sArnotkSE^aF-}vnnhF9eZ z`t22w7Mdxm|Eux1BG0hr&6lRx&)x;wi;t0E8{5n%ST&*Nacj+q^9qvVaMbLTWzF&Z zCVCNuEw2GgEYd5Angd~ps9U97*M5%QM%wA+*a&!HH=s1H-#@XnA+U25-SFZ}AC;=A z#sdzQ7p+zOQHx%$xY5|^M{$~`R>FdkeWyIg%e75niCCz%>+eQ_Ant@v__BW8Y*TiatJH-?5VLK zJoIEp3N9jNk^H+vivjz?DBL{O5$amT3n^q-Of>%23G z>wLQ)e$3+Eq?1a@&G>!ID8LlR9S>=YDEh4YtX~i z+~Nst>e9~G^Ug1&J_x0Y8%~OjXRGB%Mvj+8L>C5pZ!>~pu{>!6R%3}Icn8`F_}k&2 z_q-uaLiu-JHYkF5#=C=#H<<{on+bn>U)bejyGfM`AYSO!pvmLB5r z07q7XWD1Fr;07;gRW|g|Ed}G^E-+-zZvwepw4TW4%r>^kk6ydj3(BMz{-m3a1yczqYj5A}HqB!M?9AM9im=;{OP^~r4`jV)>K1TdI zwK?pZ2kH*(+CvKV?`2d}a0WJDY1U3W?24S)bGZemlf174naD{s*!`+grLpBLEw1xB zR{s?^tLpa6%-wdM_6Nu)K_6|1h+=5C93hK-Lo+g32uWyu;*`=C=w+V8%m$jm2C><_ z{m3qLRuHZvJ47+zBMn*Pb^rPOFHXXT0>kb~KI zZMBb=d?^FSeFhc~FZ>$Tmv#`G`f5-!JHU*8vPG~zd`B<5T|_`6#O>8<>H@EJ!8Pg4 z6ql#?YVetr^FBz7nYPrHM$PE`ldLDi)=j+Ns!VU(HVU+Sdyhe1bgV<;CFKt4L&~L$ zd_UM~<-}Wv5A>>e7S8-BFWt@aafptMJb^fdlBIZJNDr9T##`{&Xx6|3GQJgl6}~-W z2sas$M~$jvj{KTHdq=|cpT11b$L=Q|a+u=l?P+}Snp1|u*E0I>~h2V}xlEO>uaXUJr zaR?<%7orD}bIk9m;J7(|;a?LwGX`1kZ!^2ga5PyLo^BZ=7RM9bA|z@uP!5Xqxxqtx z8CmmlM6=qx&wT$|>}C=5SmOGF4Of1IyZHViEB>GO?FZ*|aI!M`N9FbRZt-3|grIk` zSrLPV71F6RcRKvcdSr27AwM$li#S7o%8FL9AsF6h+-CR3fR?^>GF6*a%mdQoAa(Et2y*(a*4u#^Lh_bH`D;PgNxz}qwd9CIi@f; zKW|=X@bjS9ffvX4z-enul7n}r*=xH?;^bJg+A_mm?^z{=g)r>B_!w+29Xn)W77h%` zR8}!(`c=aL@vB4?vkJFNR#S|QVVMO7hfEnc2S-#Le6%wXw+tNuRWla193A{NGa9!n z9fAjkTpbb@(=WHcUSfFDV69?FhX&69JO!h3Ia0^+Qrzan1w2|gWsZ@Rv#=|jt>{`yc;EAr!RAsK}Uvjs8 zw5{sGHX1Lb{u5TtFI-nM(5XzF_fiKNBvwA}Pfrp;n6)Y~fMxR0w%St)a<7sGOz}BX zxU_6A5M5tNNOQhVpN_MEWug9*f5pR}@W7^kLkSKO?9bVjwJT;*#HOe$K2(P_)#bxs z;zO$E1ES*l2lW00iT{AvAE>(?apaWVo^FjD?l1V|xgr%D6T7UPF2uQf;JwQm@T=F8 zVNn8NYs>p^=ZZbJV0!RT4A7SJ>~HS6IZIRyH)HtS4Uag_yvT>?dP{fi7wfSrp7-i# zF4YQba4#D>orO5X#q1b-?wM=4=Ho_gg3Q*Utw`o*W9K>S z<-P}?(6C)=@!Al5lmees&*(}oB+%$v5G_KKmqVOMLMNd_5nh zRk-a|EobE6Rb$Lcj;oD=L}8Ry$ZHawWVaxK7glNQFd;(6!_K!ok+uI?+irff^PjPh z-=Z47;5ygt|9_x~@tv9>UVtuI`a z^iCvY(u$fIge*eglKc&Xtu*rW`}r|LhRh(xa(YNw=76p&9UB2I>!#{KXjkfs(%% zqu;^z8`}OAd}Cg}%P&iw^@wfL`mN#J?HN7i73t?3(z*;XIG4e}bvkayR?+2QP0}MU z(O`bey$d&0Os}w@OeRhMM=`iRQ>ec=ZK%f%6YP#$!#qyZOg5|eJEwVp*`<{ac2sXi z_D1wJzrlLk$e>~ReNP6N49%-e{Wbd|=Gc(L@|EG)?uJ{goihtIUa*;&Hc2h7?~w96 z)o}c7w3&Kg(V>}oj>#bmx5VVMntP^pw!+>KeRTapf8n_13Vnv5do zTigyAys6;ZFJ6*pM~GU5GKUJ!5tUOES_RDNMX;sCg+c1a#WIVB99A<2j{ep&)GNQ) zC>>ocz0KUZFht0eg)-h4iL&phS z)^I`LdII5zrwdJ|1>+jO`S9*%Y2EMKoZ)mqIe&7jIWssl5bZ7-+W&kkuJ;{7oNy*Z z4m|;*20;5R=3@@6kwNJQPXawGOk=gLuaSK6Oi%AA1E4X)=9GH!TVgrDJ5)-cMk%b> zF%pw-1`Aw4X*FgMMwy7M)t^zi4L2UU_0&jPS*wk6@bVrQg?ktp zq}t23<#@-b0ehx|0`iru(okAw$!sQ0vL)KS^v=@ z_b0)SG?r7-{$P)5h}j<_x@suBvwTtmAZ3q z+lxT+2I7r3h&^bzoftFp9_CE*VTk+n>)?R)%k=dRlDt}-1piWO4*91UQzmS?M%yD0 zFs^K0U>;R)O5KJ&DwMXOzG&0pXmFZCy;J_}eS|zmb1oAb+}ne`Ongl8-C7 z-{oe+l`$-@d~fLRwa1QUUAi@gFz$>D?jbmfQ}4Ok`T5DPH3PKK$8xr~`Jg&BL+F#J z`WeyLycMmKz6N|O8+xG`y2;)61ipmTcbxv=rf9Dh^0kxmAiLxhDgeAy6IOr6{jlzM z%!(X?q`xgGMQ+`@`VU9*&J`#(V$LY0_XDdaNt6=zje(A5{sShM+L82#-Boo%LS9M+ zl74#WvfGaxZ1Ld`vOgRG2cYOsm_v&8qi^JMMvlr6Gl#@Kcd}#D&w__Tujg+(`O$|4 z95QH!1YQDJGbWCq3ugYUigMBB=EX8eN1wF{CXXjNLNr=t(U$8M#;Gy!i*ypyAH;g@>ue2Xd;0QU2VH$=5IV zSNS*O;ZKC21fbsqzeAB!TzTEwoI z_jL|#)}?ZNQq(vVFnFgy6Djh5O=ToH%{Q#h2=Gu^l!#kW;smT={06Z3@q2s;EmF>i zxT=enbA#r^b=Vy`C$(7IW^2|k51VN4GI5IFVY;&b&S^4^m!=~Lyfrjd;z>hMz>ZI5 zVgB32s756(jD!P2;)QoiRf*PCbY85c#9tWZKL=`N_Kx>EAk_``QI)o_($r5_8+Ise`maY9}fB_>5!L`LE=Yv zYvf*;$;3xNmaX~WOQNkW24f~@d8|hVQKG%tM_SvV5j}rGbAHx+!N6ncc?t2D7vTW$ zmFrPJ$JqJD@{_Ug!^_RXq76{nA(LFMKgR-=DRYhQxUk}7b(APfT3#<9FZNw@5NXc4 z_bDFyYuraQu+OfK?h-7|jl=n#a-nvJZ0N2-10WSU-m zGNgVhYf%48|6DZFI9D!u^{X`DUuMRz(U!%x{YCLUUxKeRass|GFm9RAw7$%F^^c?s zQDtQWZd=eO3Mo{(z%*nk&YUwUHo1_%Oz;iHtHI?X4nA2@jD^T32(0)5Ba(8_z2U6sW{j{NWfI>pQ;TSplP^n=SG1GUfeSY z;tt9acavAVUEjZpg;Uts;drk7m=hRL+J=?SG+M{vGlgw9J|81wFA{XGjG3cUrA-7g ztBy!@jYM6${ur7~UMEQ!%|+OGc?z-A#Nd@=SpnKqEwIqh{*C24#zyz9_0bIgUcZvy zd`Fsop-M)k3aAO7Scb#qDmcdxSQLMLdH-9c%@63C2+{{OdOtp2|FdH=`N-1!@&6B$ zu95DgL*{DwN}e+{gNoYMGxs@^N(%w0lusaR1VPbwu)$BloN$r<6_xT6UYF=sZAoD? z(8Qld>rWjX4_8n3aJmt_kiQ^51q~gJ*`1)L_D)B9O-^nxJj@p#HES3v=-6=sh|@Cr zB{5nnjW6nN;?9L_u`xG_x#~skhtjDlE{LDSj{05teN9jEFu?m2i52vCEIdS76rnB5 zc8Nh!pcbPunkp~-6uZ)G8&C7dC?j4OPUN6`q*p_CQ<%eT%wV(Ty(24+2S z(dx%{zx+3mXDDO_Iwsl9Z>@!c)cQq=<&`Ra-~v5U(4--ds~cISdTA`=7|tOLi!5!5 z9`70%@8n|XG-EF2g!orOoRy_8jou2G})+oT**~a1@%qv0pOyT1)>-UWH zz&0v0P-I0}Pk@!0GAlq4gjxs|<`PVPww7iTmWJwKdtFPesOd@&??h0FQJtlOaeOJB zIM@4dPeNgWiCN0aG_|BNZy?qCU~RN^+waNuApPd_=Gr6kz-3}@zmxR`Xf>D#fvWEW z;#`hIn3p^k>Od=G>on2;xZ8PxekU@7xE(?;(``a7UbF=pcFuK(B5vd+6n5Npa}X&r z7jY9Q6BjjgW(=wb=qE98`r_`n%krSFzSRlmV(exPvV7P`WHmEh7`@{|j1R%JjaJJ{ zvr>yrYjC6%CXy=nKhK&4p$vwcED2*APYoBGq&VZmOd=#%GE67g43uY@tTV38nNGXo zZ?!WoI!G@*2E1bk!Vp#4XTqFao2;NTsWm1nlk18cL^{*rqe(8>s^ZUW!K8wOw^Fa3 zjz_^JTX)ib&n+xn1z?u+23ZW(RlyhqRn&L22KG2F7p2Q7Inu3k{j3UOSt~fqtxu1v zB_-(Aa(W1{8xhNg@gSS#J>@`R;HDmB>)$nvrmwvGPIsDIa7}(e8JTqpK8HXh{0m0~+DK4zqMF+(SzRFjaOkW(5<*!|f9UGIwpE)pG&u>|b4IX*5wvIjL$Tgjji&o-LmZ$+QV^ZZ1p({1O zSvXM*e{rtS{EkqZ#XNQ* zP|4fQInvdbE)-j^YD|%FX}wv=$R3>D5*5*x*gQync-Uo)qsC;$MvN6RMGrjTaJK$L zCQGl;^XB`7akzy#L#e@pF$&}~Qr`~v-j+l>ZCsU{7nD}8#UgV|y>j_vsbg7DT-W2R zn!9d+OG;;8Z*_LXwkU>g9mEOJG-~}|J-*#R12tIxu)3>SB^3FUn|oLW)W&OkwN4^3m}=5QM3fFVj`7NHT5GEAP2V< z$U?2s1$Jx2=fyAtg}f>SBo%uU_ay7l$BX-w1(qiipwDo7KA8$@E|&!?g-Cr{0ellU zBijA=UCnQI}jroJQMHWCis(SH3fLi1VJ==2sxpwN!3?Yiv?uChSuO?CoeM zU6}o~>Re(K5sTY`R{J_&0u60UmK}kZBc1b8jnfJ!_}ceRPBcp-oIbcF+_xwoR!(Sg zZm9LKc5!S!3FRoQ?ugvo<2g{X2INb!ge;;DY8>_=qMzx{6L6A@s@j3PNXpMs zrW(!>?Zn(g0Ma&ExeFEL(v=x4aFNyWnBhc?d5!rr(rkh9_=d`0yg1xHe$MPg*6x9wU(X;C z{6s4UO$+!oJ>n*}(#**Rcebeo$FRaO?*RyO@V@wTyAc|^Y{DMs9$=%_v5Aj+G(F}0 zJ?{|$B|cZ+9a>Lu#3ojz^ubG>S%O1Cz63XLcU`4UjRdmY8CQNCKz8xwBO%}=y8a;P z6xaDK5RM0VBHDOLig;|&^UfSC$;{5cd=Nt(kxdX+zhyE4k$wj}2u7da8G?eFP`YBKKH4JN(OLn~W^I_^1 z)2l6IPaZU>7F80_reWJQ7@hB1QTm@-W(ViBo*og;6X%m|?BLJu^tgTy^um24#QCBv z&*R2b0yn)s!SC+ya~W=0^xRcr^XO-*utbNQ4hA?U+1?FLWreR_TSZ&mk5o@~y=i)W z^fnCj?y%`@Lg5*2l3-+x^(!#&p7pX`Rd{-0ZG1Vu2ur=#+rjYM=&A$v#t-Jb-4b<` z4#EqsPJ?;v>ym+emHb-O(a=&^(a})ApVMq6Xsb}off(Ve+*B2<)*V%cJV0$@s`JBK z%1gmQqc`<_U_WR9dS#KRiM&`O(9fL{)5TBDM3^qNy7pV_2{{9{PG*Qm@3b^xh4K*W z;0dAg+OaHMh3Z(;{Ay^iK|eA@+Nr9EQ#GTpsQ>&|PE7GWedW25LNU@WRh3Ssm9}I6 zFXb=~0Nu)$FXuCk=Rx%{0+{=`8YZ^Qh6oI_HJTa4H}n$)&O$F~xUS93`@RQmnJ$&cHRrs# za&eh=N$=u{L`e022D9l{=YJPr4$M=Q$hD|Iv4F3PRE^bfCPP>I5)o*W#dXVZ(rXu3 zLKvFhIJ2nE7p^aDQO}L>?k4KMnNdNYpnlMID;gLcB`UOEW*8mrthJ%zn8lQEK~Mo4c=g{NQRn}yU2RrlFJ z)R`?06w1#=EA=jXM3m`W48x4HTwb6s(acfpimk?!jEEEpnFd=It;imG3AL6sdKi)1+@dk5{#Oe-)d|re;4YXihWcO}Qt83OB$zcqUu{8v zto7MfU|whXsxB>%s7;xt1B{U*?0$qAJ>sJ*EH@&V=(eR%n{=#y!AtNz5ZwusYk7^q3JFF*Nz{D?m=d_^g#Nki$U_~q9l1EyYC3&m0P%cVYxDy3hCUeB7yVEXdx1` zgu!OGVqNR%k!-^YEews`HXzYPniwAJlR*07m{Kg95!$(fNAecxlj4dabV?tk@hiay z6Cv4!(Rhr`4vfcg8+K~UCp-*3B7*dGvVXqT_P8vRb=qu`m*g$H33&j1^1M}uZRTrY zN2E(KrjdMuvS^Ayk{Kk$iI{3F{S}Qi%VlQh!`0{M?mj&p659qgp9cA$>yNy>+mqw; z=Ulxuj=ubG^%&QNm!XnX23@<pfrF>=4=+s-vA;s=oWT?2y8VXt@hyH8ueRtvNbALHa zhW}jioa|E}!@OxDky8AKrIk8c>+nxgC04Mu1!vG@QNI)Ul#C7LW=2IQFN3U&WZfcG zEU@|$!fw|!eJ9?ub94F3)tI$_P#FgdM#aZz^u3JxcP~e!s4)$@-Nk2Jq8U`@-55?D z#>R5GIrKn<=+W7)u;fTMBsVI~uv}~q2L$j1GtWR1cdDR);Fa8}V~jkw&6RNvpAPho z-rV;U_$EEk4pZPkxNoNU-kisMfIqir`zB!1?helm39uZ1zgv@aHo@ciDC5<>zHDhV zU@dzMK_O##d~d6*Ws@nCx2cga_Q{5SdK=+Mek{Nd%>t_Z>+tTN&>cc2d+0GQL>f55~Kt$`9 zvxVY`cQl1F3;21k5iHk*8{uu(Rf_$~C~(2BRZ%sMIW#~b4v|Ve{5BN$T^reLO7rMK z^h%p<^@YB$7SDhZLKsznyBf6xQjdz`aF>Jn#~4ZsGHn@t2_zQTme-sa;nTf%Y56|Y zzTt~Yj%{dMo8&_LYu86v>mRw%|&cpNt*S13Ru2Fn#B4(`#7 zY6aS5=M&8&c@JaG5!tR}eL3zf>xuB5ul6xbpR1&9$VoC9b^0D$8=J8iZK46ppoW+e z=g~RI9!~!90OblC?~f3*W@wX5T>A^6_uhD0Jco1dYo4xj*N|Fgy-&|%c4*t_NRs|@ zC^Ea9caV&T73fKt^oYY`R+~Cs?3J;W*zAad?GEhdT#*4_@Hb>as@Jc=#EWI#lDOqx zvnK9IQy63l*7>yM8zGMfzye*vk^|VeR+BzEOynicM3=OWp(-^Xg@bRWM*JKD(+;&R zQ3-CEE89s^IhKO9?e??mpcv)zjEIt4MXV;w@CV+nKANs^87&tSxnY zwoV_|xwfKXQ@X|Ww)Ryq5eoE#y)2Wp5sZ=8MatzaK0OQcjf4D#5>YfJbz3Nq2lBX> zdmw>Pui<8JVpot^)idsXe{8DN`vT;HX0+p$xC9-4O|XaE=ZKw~pMCDl&NJ9kZa5|H(%FStDc{=hziqg?@990^V9td#zmDwv53xZKT(EueW1F zsER@;3p0?r6y0N<%}av0Jrqcf&%Qf+l`e9|5*G0VT-FND!ae54xK}d_{ZD-;Ms3}% z;TVanW>5Q8#S<14eFk(TT|_8Ev21k_WD=7@AEx1AShV zb_=1LW!upiRKT1GF3C#o4Z!(-tc=6K+AxNj*lkvfoerLQr~mw8AM>6%c6khk!e04f_a?c!hCckN+LR>tU2gNB)xphPRJZ~wf=pb8|Xi%CO zY<4WESPWLY@7<^#GOGl;U*=%T@^Db9K3D2ar37oLBr#RFBt7>8S%&IZW+Yk5g40P% zCE-8p2|LRiUXng(_{OGEgp|(XYtd3_)SI9qt-$QI2z5@RLV-f4RQ-vx4H%2E%{#q8$_2U-Rhw<;EBI{J_(TGkQW>3^ zR>Zefp*Dtz1a@70VxEF&cmI9GIHZ znOW=o)^sTBYG7ph+aG@%JrZKIY-Z`u1EUx7eXDEX$*^!@m0B|*wc^&PN zZOcB3PM9c(nv`T2wHM4J7NXEO)K#sRu(WzTVeiPSp@lLsKC@(-i_fYQoBWx_nQoS{ zk`W)A#gQ6}JZLkR0@qJzmT7CSPsq(QIGz_!CQ^x|MlVlaJAm+dkjJR#t+UCdP=XyY zOwuTqzX6GlMzh5b$uquh3q~`K?C0pKj5|AI>S#e&UA0gvc03E|$F|gssB~k1lxR0D za0J4h4UpcUUN|NklR`S4o2?GOGEkAGQ%YG#HmcYy7eqe%)UMt^FQA8cACQ`)zVC*sUTFE~+XzXH5+Y25db-vJ%WoD@4jQUs@KK2-7m}1D%dABt zdZDG$X)(&%sj~rOZKpLLjFDud2}R{ihIGrTp|>ge38fz-E^?po&I^V2aL8vNC&FJA zN|O21I4R)4P%_ziX??EtJEhEkf{5GP_e>SjOYxPw^W*L|rcx9)X%>-eA@!yw0@;G$ zJOS;d+745d(las|@VdIIKpv^OSwNN@+E+aO6xLk~wx0@31b~1?27=%dlu*wT^GpXOpTZ)MsPz$U`&I)DBV75oPBs zYBv4u2+e2t8!G$zQr=>|gjSvs&my8T_D;Jb15=FEA}TZVGY!gQgd6V19pp(9?X24# zlKRWg^IE!MBV5G5zEIC3N5d7;a`KX&`VdFPFvb`T>?iVi%JqF)k{263MwHSg)%0kN zw*)!ugR`V)xOHSWK(vioqGLSRa0!hW+B1H6>&d4 zA{Dg%F-jqzXJBDtYz#28G*WQt9T8>y2bxXWJS8D7j0dG-#77h0ox zQ8rDU(M=JAT9jBR|?W- zTRmne|F{Hm1wngpX`Le{hM>~gae$)q!`x-A??q6EFcS_zE*DqoK4Jh5Fo+QQE0wAh zr2g^nD@Qa;z%K(;BOapQSB9z;|E~1=5<*#kDsdmhS7oRg@en0}azy=vk0nbKA7QZG zNl3axdJ2qD45bKjk?-9U-pW^XVOdJA<=ZAGyk(DS{gb~hiGNc9DM!>z04f7jCGMgC zR)+d6z98PqgxF+e8=vSTZ{F&VBM*gO^7$D`t-3JW|XLJ#l4~Bh2TLi8cS{ z^ZR7ISRs}cEfJy>3Gef4y~d*}-$t>uYIlt@Os|JN%%W)v_-v-~fLa%|D_?L*GZHea zUPs&&q&cT>+&DYq0Ybqq=A(0YLDJKK1x9f=gf2b$I{roL;sYK8WiTk(T*E?%rLM3> zi`)*hRHwHe7tU#)${B;cFj2LfKZIk=Ar$mV%)^gJK~v*`#2RI zjo`3lKr6iyf%Z@`Qm5_d=TQH)s;b!=QMQ=PVK{x%w{KAV830sg1DoN-3JVNL#mT>n=|D+laVC5%Gn2C;-oI# zphFVe!})a;^0Q6-slF(&WS|wmN`_J!M7-Kw0~MO!VkE_uyn80fOjVy23q_d9lV3c~ zNT(=WWbl#F4Og?9nNW_cXf-PlqHa*|I!0MW<(`%qj7$v3Kcb4C?oTfm)c+FqtSawr zrLUb$6>Z9IGni-|}R9CDCu2Y)+aS4-|5orQi zQ9@mDJ5j|cNgMLseOaBrAsTqVXh1^GUJr#{105L*lnqKHLM8G7qz%$fnsSr{sFOh0 z9ud7b+k{KFEpt89W|3y)B`V7=jh`2xRs&7~u>#I|;I>5cifrR->#8N1gd47c~S{!;rOa2EJ{4SektI7Aju zhoBZ{n-zQjquAOv>>iR0U%-Xkjo_vY#|Hw)MO-D<=Lj`Ia`1H6M=?TeA&Ft<=Q0~r z6!7ZW3yHXPUUn)`vzv}g>c-w(T8fE%UKcagWP9o36b#Yv;+TwTz}(vB`` z+U$F?IiB&Pf|U|Qwy-0@WY(zMFY&T&&uqrU&qot_wf#HE0C>$5du}Q4=5Jt+=`>-q zhjcpm{x8HhGgXIto>Ieau*9dt;!!qc_8Zgs-ZHaqzz~;&a9gC<{gY;Go|1`T)Dc)} z(ANi(lj;1_FA7lgz;G|a`pik19s)_CXAV=yl|+0o9WkBXeh zDS!=Tv=2D#T(2OmU&=YvT6w^aM~eif)M9}iKof)APS~Ivmziefwia(5Gdtmu0)=J z&-PU|!kNE=yax#e^!eg-MGK5sdWjLk=?>rQk5Bw?n>nr8;PnP^jXJ}ma5dbrLxFbf z$r;b-?cTba>tXZ_d)IrPI&*6S=|NFl8=k4tEPUdNDyrcZ&(8GTeExCLX+RT#*W9LE zwFwQPeEGcd;)m(T6?5=wmWZ2hnA?|P+MftlwC^O22sWPsNWurD;}ft0Y51Y>y2Q*VSqQerz*{En|8)J?AG zeiq`)k$VcJ)1H`7$!U-prgTEsZ2OBy5b5$&4OZlicjeH`VJ@k|lR);uWFbYw21$AC zb<&Ts$?Nd?nlNhLig)>@8o$&?4b!FO@tk2j4A|?ZNde!mPZ&_>XA@nP)1{R4=#2`( zkqd5-O@&X}*qzetJcBj}o$P~2Q@R@QtV<~a#=fJNQumct(%l!Rt}=PqJ}3`Ri)1gK z{a=Bo4>$u1#&p?E7?URkV2F#Ndin@HSX>MH>e-U^#6Rm`8T+c zwKw{xw)+z~Gpo{bvgkouopf{@x%k#y+~>dv6DuePLfFW{qUiox?X%=Nn@g$clI>K{ zl3bS{?PLb47o4|!B;&JhY9~^0l^Z_ZZ-`$gFEAM>+MJflBnIPF4vg!LLKl1TKrqpD zeLn&JUS%i14E*<+y1!KL|1Sz;Kk8+He;0l^3>`cof6v~y>8C({{nmtgeHoHff1;n< zZ*!4#4|*=Dl7*{g$Z+sIma;z_R7ZJXez@kYm@Pc?dMA?P;1vKI(~az6Un=OHlW}p+ zZ-cJ9GXve$-WP_qrI$2r@@ukiP2}3S$vErYRa+d9yVd8#t zF8&|h-Z8qeZCx8prDEHt*tRRSZQD*Nwr#6o+h)bKZ9A#t&b9Zx`|P#$x9<6V-8S2p zt?oo4`f3U8>c!bIRU|q}1Qv67knRC47 z{)5Ml$tn2{l3k}n^~@O{nxTO0gyu)aW}fQ_&ySqRIRK0QA9Pvmd|qn>VHTEo1<|i< zQmV(4UQz(!la~P7v0|He&J5Z{{uEW`E^V~(&e-W%rv+ovvtY;7V1H;w{HzQ**hp?dM+z8F8FqoQ(hKlj;Ay+;w(zSF|&?`9IXV@wT?JawtPNlF&4` zj-ig>8JF-MUxF>0o<*`q#h8isnUnQA-6>$5%9|xA(g&ZF-(iq+$IW)ZuLUt>>5_KN zp|>&}FE3trjyTwUznrbX13k$xcQph;laoVFD1HGKiiP=|75PGnKSn0-*Gw_!lh z2zke4g@e!Pg`_Zk)ZPh>!Ax{09Lr^W=RKim)Y@qnw)K#i-r<=FvwCKI zYU8#maP%w<7IYQ*bup&ciYaci_0}ujj~@~1$MUNj)#2@!gD*PIX*&| znX!?uovopnpp~tmk{v{g%tm}7 z&mKu)6&PEc9jY!--iY%$t7V%$@dOk<7eD;uvTF(hJ^{K1{qx8zVt zlmqj`0gMAPP3v`T=aI45ejMx44Vz?_x_xY?7I&}0Mo*u;M+Yx2PLhoI0 z5;mv}ZyXPO1tjtLyA1{Hx$r)lxhMb0Asta-9W5raiVIi4xO>B?Z%<4}5tZbZ$wF+= z0u0yg2Tv6W~@U6phuNIQ`BTqVS1qQzvMz|iOffkJ}M;4SOV-M-Ndhyk+mN+fr?aBsw!2Bq1C`)a6kOlKWrpu{E9tQ#^v2BARNEd zVLo2`J-e7pGs*GkVKhNBqTJ#(^7SSd2J3dX;+PvPkIHA_{{5TW-9Fj|kZOjl=-4n$7s<~^st`6K9Ol1yLS-hyk4%)sFtNH?Txf8GAM zYZz|m;%yE$JRRSy9@`z)Yr=Otv>oP5zj^>~lc)nkvIa)ltd~R0@6PUvN**k(8|LCR zVFz%^wz3=S;*M<1my{hStG=8ax@%6Ypzc1jjxV+r3vIEoS?eD~S3#bM3o~gxBW^Ml zVHLluMewN=HEp0hfh*^N=X0gom@v5gd#la%SHJ_R@z|eT+ah|MB@`t%AN>`W6sswI zdp~w4{jSV>m!xDY?T#VHf856w)P2qg&{C8sci5vWt}>OtnYJ1O*Yhgj;5Cb$(``#D z@Ce9YDxV_YWM<%ua~E7mN&HduIhc+YJ8MZwvm~iwG3~{(67W|=<_j=!+8vQ5f-+VK@CD_iml|98=AR$!6-KJDT;n88{S z=b@{E(Saa<DV_H#SX6dq17gbhZQ>9svnRl?g&xYN_=ojk(Y7KRiNBDkjiY<-`*y#9bi4K?K zr;eHwQ}bhCbu8FBZW(YLs>tZw%SmxG+{Rb+`<5iI5^o1(abfGm>_sQq+G6V?Dvx=94dx=D>wRm)+^Cu}-Khv~l}5l}%z5<3ZVQdP#}dXdfkY z(GwWnu{pay^PFzA2c_ufW#&#-AF52?(cf!)#o?Z6<4bPBXkd5J4g@~{_ls!m6Q zeo6NDmbxbPQ>N=nMJUu+IZxvw=%2?f4`EDA3jmTD0FVS^mHdrQ&_BmcM&HKvPZ+7~ zxF&=$bW^Y#hPxz9kO*`@fP(m{pMuMZDMHUQ}kh~1p(2>|kjZ+vtFTc+Sz({iX z=^cOgo)81}_9M)_lYPSZe`93#=gS=(VVS%_zPUoZ($B8VXA&$qx!kJ=C)q1FXeYJY z>HND3&9$t`w>Q_O^v(;O2#YMD2Qg(4bqwWq;zv<)tO0dl<6rj2s_DTpNbqa=2(XX% za7t)DVIxf1cj#4C$YH5Z`2-CL5`OlFV-<;4kb*ZR`e4AgC}%e05BS*S=F3kn??c|f zm!GjjRAkh(lU6`G_o8wOc2X|;6IDR5@KZXM&KD}ANN7`5DQT6qDA*V7N(?52Q=zK< z~84wjF5cvO;a4f#hIvI1Q>M zWs{QCKW^-b4aS8Np^8#QE8&!~E7-R%)*}w-H<`=Zn7{bOG{t|R%Yn|KhjS4f{{8Ku z)O$emkSnY@|7%k4D;L~hegE}9ez~b8dxt?dgU?COuwR;ONHKm|<8WyqF3+db5Z|T4 z+%7(}#kJTV?k@%Ex+i| zdtbr`mC3HjF(;{7Vbw|IzWl+tsSNi1m(MAZtx&Pw_l9gE)Ea8>;9LqfH4g1QD9`Hs z>n#d6@ASN%m;36KVp*BYq;O94%#k5c2d3_0)5hL$(#YLbCE_Xf)(5{CyDy54xowY* zflsC!uie?AVzzoyjkAF~71 z3ApNg+HqF%Q#KO>uj<3n3OK8Q(?0Hn*ZXSI1HVJs@rBP{+6}pB8*M$<`kCP!WYeGP zT5;Jgr&qf`2mO8I=F!oS?wMjyRQ2QA8N&%l-S8TwV~vFNX7T~Z=?t&s%oi^PJno?0 z?wR>1S=cW7(`~vFS}-;WSq_&+^wCP{51E%w6S~@0Thtf2lM(+H-iXl6y``Ym>+0cF zR@rh#N6zAEQ~9jf^V_e}8D^7F8IJc+=4dBtHxsQUlLVY>d^~)2fl%EFm$fhG9wy%> zE7G{DQ;;lYyqH#8|Jq4y^tTe<02VhG07x?a-@c@O!N`BL<37EAU}R{x$NJY@r#4nl zkS~~n8|-?_nJF?%D8q~Mm{(&&$nYINbfe3UZ_(WK;&%-`i$CUmo;~H{bPElPz6D20 zHvbbM-)1cu6HB!J4Uy$~uobG$H2=RqBq>`0Go}p%rmhwzbwvH3c#7jO7o z%+5@1>bOfCISx*+y8@sc$HpVmO=9L!-+b!x&MwSDH#TP;y<^AyaY4@+?Xf{Wu^K@A z>V)w4Lwt2hZuU7g>Xv*{a&%;!Z!Dc`r`b+IXCym5=@XJFjiUKS0R4r>n<$w*a|O+a zn!SOrOL#jevVu;+zY!A9gl8AbIR$4I*WUwY6`-H|fslXFtfK!3AtRi^Xy-(of_RIh zPiN2`O8-!*ntcas=d9SW$f_C-*-DqB@$zXopM<+mb2 z7~Dw?X2?VCZZ$@?bZBDPZktv&OI7|$<#w(2L;nmgahw5@=9bxeg@)AWXI-tm>(PG7+1{(n%h*+wmm4kk?FARjyn{$P^@Io ze`d(HGsZi{ap@Lod6;r2PnJ!3Sg$b~HqI*dE*eKE(vh%bb&(RsRNYBzWgyshe9`8; z!0EY>JklkEQzp;TlSRirS}q!j-RZ(u+C4_x*|xZ27`ZFPkuq z^W|#|8D+)Q(|qq=N{e)V8q-U_rbg=#_Y{ZgV@mg>G|+M|JPMAE zZ;HJTzct3fF|6U&*U{D=!o4$$_aS-Psh;?9cHEJm7>T<=m@>ikP{ruqwT zk_m~Lk7r-Y{44zROV1N}qv$7hwJ^u&Rkl-6h-N3^`)CDadfh>zzl)8XCTF0laV;Bj zt%%T^EhjIgHdQ+H+M8KerNGeu8%JB8@~no^$}KpnwCA#o$CAw;|;-o}4u3?I7EE%i0&+Z$Ey}UOUEJELqu{@NY zVA%H%$FvK9HBo;`B<4Dg%gkca`Yqp-R3C$)_UN`g)+$=dHg#()Jqaz0ZJ6|gr7r0R z4cBa&rM=1YGy2u@XrRy#B?G=Q=13EZu2A2~;FgJf`VfLu4F;lg1 z_|x96@J8A(u5=k~12_93W=zU6etraI$}45|$0UoDBwh|FRJkce3<~uU#!Ru-a#|)( z6L~wK;nUhA2OWLJ&v!yy&U1fiChkUpE8}VXRd*4%r&Un0$}2WvRY^S4Hhw(H8Vfv6 zlzrtE@)9w=<*K@%hFM?0OoW zWIC7ykNpu}bfx)R6}=Zlh*(~9WvxEr-HVIxLYA?*jpbOpdZ?n(?eOq&H)&zqN3r20 zPTvs zK8(N|GkI0h9~=ugWO)e`o9iy=!AYvyar@KfWPJT^CgIeT(k#(`w~o(RS-f;~*qDOd zC&DzC0X%RVC2x4Ery0{W1!#v^r_Kh<2FHotf^pySI~XCz7VkXj{c;eZ>B@|j?(S4b zG7@BSaHx0%8%SgKJ;H6tj!zPF!hU{=hT1=SK0|&mfLzL*iSigP-<1p+h*)e}sM~{M z)nZ<&uq^kLNNbgQqOoYUt{!H+;g|;YPq=22!x8#2p4yTQAxJ%65hi9n1EW6W!6+p~ z<-PM0a`Z}F5_;l8gT*5!CG{K1wJRnC6qFo4HIrm~o#`2P%=PggM+yhA)z@T3fMj8z zk}tH_fmfT)38&mELBSZ@9Zg(Mc*fgdS$ZcdyVrpZTTAFJDyf1pqLhs`5cfYTbVW>~ zb)}=Ez)n51NUR?TqP78*RG&h^stGta|G6I2Z`RAu(AQ(5qt|X1gx=%auty|fcKx9W za-t}>mG%DC<6jKaej-nFTxhS$M6lW`M)Pxc%I%x{hdADeVvS}VR6+y!AUdeEKRkaT zzC%i^ssf^#2s+*~|04Fwq+nOq0Gpd8vs5iIH3{K!;TB#f z$l`k6hZ6DhJWeFoaIMrfD=S+_JYT^fuL_J<@DPG@q`?8X3gUIy0t$#zB>tcgGjn+3 z60p#FwwQN--fb^#HkxoGPg@6w3$i0{G~<%D2AKKS^pE)KOp_TbxNp)3Zzpku3%LiG zs^b1Hi**rC`2naRkU@bQ%4Tum?qf;WnB}lI1n`^qOC70AOCnLg<7inVyx}$zOSSm#V%&$CO9q1 z8b4JYtN2QWvVya4yzAkMH}-P&k%BXv{p;rSbKoXq{0@wU&HOEMF(&PWtYS~m{|%F) zi$A)Xcvv@Xulmy`+M~lR7V8wU&=TD1^=AFUFcYlRkoUJ(y)XnV=P@@>eyf9*jddeg)Z6n+p1KpJP|6$Gun^B zJ1&Vpjyh?y&lG0nqJ3e=yRiag&^N|`Ink4V4498#EN#?!2OMJ(+NV3Sn!Iq`n?aFU z`EDSah{GyIKUiVyceX)818K8#gnpx*#s!M4W>K%A^qkovjU>zYJc3wTPOqxcrUK2X zh?yW0vqywJ&5aKP+SyM|%cc?_CeR7Fh~FXLWy*WtZIq`btgSjn$)pCZ^m_OfJi(U8 zb@IyAWAn~mR5aQo9uAvUy@eFMYK#$xkrP_pQ_Yvi*h-_w{GXy=MmtY)y zCXWn{EDN<{yd<2cxplyXE1=!OyJQ-Xh7ZIt)OvN%ojak%U?sEXabfK`IcWW1UJ<}* z%zRx-p967M8p*P*m&)@?h0`sUwKP&yrvuSeAozZa4Y^-Qv+=BG(t3hN`1HOd} zX09uq4Q&ZZ>LoRG6N{`gumn!j>(u)kej z46Vl)%+xum_lw)dWsluchu#on@`zkRFbzZC5=b2I1v?R1WE%nHB=F?+l@K4t)|n@2 z75fy2++%w2e~LAU9w$>Vhr8ZPij@Rz>x$9q(v#m;Mc>o5wk?ZW3r_YJno8iwv?WH8 z+qOWbWR1p;FVD*wN_O8+Kg1+gMJ0y^pgP`cePhesRkHfwo2K7sV%m+jo%F?EFLTSC zeUE7J31|MlH02t#9caOT12+*so5=OQt{TQh(#DRC`liNW`Zj>Y!-1IpKSD6F6s=|F z5zj3d)Ve-ose<-tq3BGhk|;MIK|NTv?a1g4p>h(d0z^Qhz*#rc;5;l zk2Yz*2-90O_qjQE=%yTHE`Q(LjkyB3qZG*9FbA8CScsXs;q_xA2dXbJ;1z7wjkx6* zD(LBmDr|>GQ~1%bR8T^s0L;N*LF3|4+3{5MlsKAy*Nv@Ow^!;l9==rKSiazya*XY% z3_n@p?T_NYdrmoD6yUaRn9#hz?uk}iOg+7#l-w=q6gEg_jXh*#QOX}5yxJ7Bwd=~~ zPT(h6yrC-guCDn(5*CkNKt!FLjBjht*SQ)|VN`OgZ(d~Lta=CFw%v;+T%28@SQT3i zpC=w@4QX;PUE^+28iA2Y&2vYzf{(j`$mU2LoDZPY@`ajB=J#jm3G&~9;Vz7SQ3k)l zT@{>n(#QnG&EX81CCo*qY1Y;1RM6bXO4#-NY89KGdgAOk=6wNiQtwkf0wwUZd2mAt zQ>~v0_6$k|Y?p;T#NRI@m5n|c@@qmLaZp-cpnu%i+{{D0R!l-inA73t{zJdv8kAY! z`Df|371b2F9MPR3O?zz-eaA4JRSce`YZHlMFbJ}@)bqW>o?7!-icuxRLFUWvy)f?Z z5QFGv0xyAil7YPOqMBsbakc8BIsF^n-gttyw$ypFo+8gkWh3})$v!a^Gh=;T1_<^V z)ao<(kOZ8*O*QO}ej_V&4&m zQ3Y+CZJYonqz(?Y4*yyz{&nu61aMN4L->%fJs|Y;3x`%(>jfmbp=*8cTaad0XY$6=r9=lwr-|}uZbxqLi_IU@Pk7y)* zjg25m5W)*$2SXMsAQuu3O#>N~i*NBS7uV`{CNNPv9?lHJMzWDeO|gsMU*u?hX|rIF z%3_LCw%$~lCvB!tR===UhRdaDvg82PI1RFBDs0U>OD<@@U9evpjW=wDq4}=pv~E_N z>Y`~&UvmUg3);_^DIEN;UQ6*w#_yd#P-npA6#P-9f5Ot-Sa=8PJoYogYGF~yQSl(S zCSWYI-ns!ZeAwtF3_Iip!omPHMjuC9EHRI89S!^-eR}z23BdJGsj{f9cH&}*FiBOj zkAogFI9iC|=UH@Fr(4M-7%J&m(-@1_1j5iUB4`q5OeCU|L<>!UKPV=qkul6}Vk7~K zWDAiYqASUILT#WiB-O6B#E@6TD0|2q%nNdNj()D@b3rApwj+i}bQ+#}+cwEkZRg1w z{Focw62rJ}@Zt3ELrPWeL%Q{X)|^r5m30w(`ThDlu8rD+#E0&*uJPhl18yh4C+Oh9 zX|pD2807*Xq^gNr?>f|Pn(*TF8`db8DoZEVwjhW>Pf!9Km34r=xt1+rk7hnNa~QMN zB*7~$ID&|ZR9x3>1qShnF@xkRqMRy&ghM2C#BJ+R_mOa}>ZJYU?%yI0i3K&hpvb@}oW(0I=Dp^M>jfiPS-)RM8ULKb70XPTYabsZrHW$fpfPzwlj{$Y|-w_x{0wglCg?yhEP z(_AF21D)cDq&nMF74+6f|7 zbkcWn{+IC>08;;;vv|{@KxykEBWy%mm2?2|H#v}#jRR}N1e)N5k#>s}s9Y$TixNpb zsD_bDnbW-gRKWFIEKu15Grd`Y}1i`M-GBa z+BVTVQ@dSFPhr@CYgR4&F_$Bcm9M@sj_A@B^HrP24Q74zC zYaAYU*pq5ztE1?LRs<~Tu4w%RYln-yZp+Ob(KD{cLU2FuyG-4(Z1FLNgAXx0b5FWV z@Axa}@iogX(u3z%xHV&?(ugT*h0gKO((Tp`o4WgBI|YQwrwc7U1EkpymM*@Kp~Y|p z-4PjA9MMCMWw57;sY(iln;i%oqDV;*4K^wmZSPXbg|J;+}h5l)kz92+=fOFaBekovFZM?_VMT zYSFigeaMm6s6CoagJhye9Q?xAr(L3g4$cq2Tllog~Oo+o`CKfm|wumBzz{0 z5y$-8laEahgo*j315s;+a5LX6cv`rBjcHIE3jRF~xCQ};1<6?EfEjyl%fY=j{&A-*`=>|r!eaz>t-a`ABb7X)N4?WcX zuk+CVOsWqAVDxe_U6hPMh+k_SR(}rnf)XWNi$?; z=OD{Y1Ij~hG^kdwJS$xM(Qojhw$hgvn8u9GqSEVF@@=-cs;X*XVW~( z2JOk{=%(q`$LD9)XWdiB=dY7`psGQ91GAw#B&~p{B)zY^blqLKI}r?lohRT%cez%0 z@e?UVcXkwTdx)^Q$-h-4Zj?QxS#@J}u^G6-ZIkn1V#MuZBpJ5CZ$^;oUYfL?qqW== zym<+UyREU2XkvpLfO(m*E}jSg&d>0#@7lJcvvZhB zwT96wl`(Z2_@%+2D6VmkCg_Jq5_?oomB8>8sjrxuZ<hNMYTjLr|iQU*tiBNkR_8YLVa9oRd4I$7IOlJ;lT)1m%zxl2D=n*=);(}W@${a z?oKb6aT-oe_kF|A*l{$qW=CDy12RXK;fbEd7Lq#M`gVDwVdd=T+*VR2eu!~M@U%UBuS&AN^(Po)bD{UeCwe}1IELK~cibuSa1lt#JJ{I)d%TMa`=yt~ zNCyQ+4}UQeCGIxKg6~|MOahcojWj44G|W;vT+w)3=E1T$Ni)-)(J#mEhkD9>)-Tq~ zoUyyng`g2@C8JoZrjI3ccMac3+$rL1<1)F5V8WMlan7_+YL`Y_o=+&$$5T0&Dq|gL z1O2(_fg@V&*QAC3hW50g={9eMWodcFU^a^~VZz#;vIos^UdE&4#0`A_CvaYdloOF< zOc|s^>y8GYxIk&C6SIm91qJxyrDH=iM{A@th_9I1%k*nx+Axw zFzUXG*qRsh^Uv zFLVDmFiOUW(et}qS%_@z9T#$)bi#DGq&9^+ch36yfjhIY#M47-iMvZ~anMYcE_0@C zfU%0@STn^f#zLU!To3IF9{q+knfZ8V=Gkhw$!F1Ol4JP9KnQA6!uM$wS6-d^E+%^P z{ppdm=p&ZmYH~80=C^i6sGr~iFTuWga;Z3;7QJbBtlNMGr%+@Z;+zSIIkn5z9JT}S zW>1~{Omo*n2H-bQQ4y^KTjKDxGC8H}AIg!V3Ql!9>9{U!y8dd8_MGpS>Zpy8_GVI9 zrIZdLqtR30v|!E>8$i;yRhE$(;>{2Zi&q`gUcxT=9QXwj-$2aN2qn?B`o5@xt!z<7 z$GT9k=7h%(t6;n$2P2HAK* z$?47-<-xo%FPX)v@dprUIUX9y^-~=CvouDUfUa>+l3nGUPE$}LxS=`Uo$3eU7mR4h3PYC z?AHD*1L=4uai5!_3lbM{`Yd;#iv0@Fgu0{;eE?nxJ$+}X+1eDfwE!VCqpc778w-qi zor2j4oHrjao67ZCjB3F>+Dd^NSbrC)Guu^KNV+J|IXk+>c21DkYnqGNNrOP!Y$D>m z-o1}x$yBqiH(5;iC#5F{Rk@&Y+@VUPMn-?*q7OUaQ1J)h2^`vV7KOkQecb9#r$CQO zGG%qbNqzY4Cj+1COB&vdbY?!;=A_~^g%iZwNLb#D_;oCC8}J5mhm64YqYwB}wUPF< z;s<`bq--rJf_vhrO&qIg?H?e@zgA7?da6*q)!dZ&#MeqNvIbbiaXtf4iaW!;9lRrI z#E9Oe$%$ta9uQD$Hfyb_1ox1IQh4z0ixA+$csm@UP$U?-)7@U zquDc_N{&$dBesmXV_W8urV*19Pc0ja=|b&z<~*a$@w!K4v{C`cQd&DqBmJix#SVT#hN)p5;pxQQycx$kX zNsZGDtTFPY92r@S)$bW3S+zos$uB8EZ6To|S}OO_E_9RkV(EJvcevf{I>TvnLJWvC z#r}n}hC`;lmw$PJmQMzkOk6#a+LT3O5~w-&lFQAP3ajua1mX!VbWerUDfL#yz^? z3tKe^K4d|kdH#q{kMqxeBWF}cQ zq7bHwdX7-c9a`Cc+)H^}PBmg$CHNJko}>h+cU$b>`!kVPWGna35_|d(MiPb>&RJN2 zDr|KAfMAB%w;KDz$I=*)q>m(O-7xNj@=^o?B2eepQ(A+SNYs3AOCdU>^QC%QG%qMc zt-~|2PvBZZN;=cqrXWJNGA+El zjIS^*{3J`;t5FM|e^IwaV%NUZ0Q#dITASHx5@!T4xNYJK2#yHKBFggDwM?_1EEIqiM_*!i=ZsJvk4=ZqC{|? z{~~b+zX&kv0zB&p;QD*^+&`XK+T75=_CMHj+R@z>!2AdyJ_Uy|bkb1Rou^FCZ2A6hJv<#(Q$O0Sa0VEBy#%=Pu??XD)Iy9LpUV?o#No9v_J z6bl__HZ?BLVWc?B85H`*f~8KFNUG;SX9$r(&aUCtPMQsys=;MeGA>jIZmc&1X;V&FQ6XEAXl(h)ts7`imP< zPM@0z1*#(Ldc;-ci^Jqg7ZcafAG>KaK@&JO`Wzvgmj^Ze%3q&gD~$EJ1U!xi`A=2j zt$a8_g22(RU{;D1em!Ffmd$V*h`HX^>XADYB7yhk()9^$K7~;@H;(-#!jo{si#u`q zMil%|1;-QOk*Bh5-{=scPp)*{5xcov8QQ=XS*U`m+kVxAX%qgmirbOgW&1CI0I*SWyWMC9G6k0l~Mu~=6GebxSD_)+3;a51pyY3~!RB@>{E%(Wck1)GEpOVdD za+$?Y9sy8~@7^-+h7&9P5H9hPXFT5E)T)LB}`ygZ;8n}IL0dL}%5n4BCa zn1fPhT+6BwMRLUBr2B*tfsevpMoZ*6{M401C!m$GBDwqLDTG}LU85*1_ayi$+|BPy z#X2p#1b>8lyKC)K;#XOuN`-qqQR@)G^ONoyX5NQ%-;ju;CKA?)@*cVv5QB83mjwo` zYx%Ao-ZEHAT&zK)o{>2I>osuQv5yt@c)DeS%Hg0^%bS{wC*H6nLrVSiFRvAAZyRh46v3Q8S2pyoksItX;i{8UgH^l`yLTfr_? zs!jD1=ZPZ;-6CE$!qU@byYTcMqz@Sz67n+`NBSm@=b4UOR~fcXcT4a&KvFy2SOM&D zeLzFhnd1noaUwVgCY0xW=JlK=oQ6g9Xp;}zZ)mVzGn?s+cl?9QgMZqP_gccF-6D5Q z;>L`%DMHo~c6OdhsOp-A9^F#GgvIM3!~8Z@4KH+YR4#$ieF!9YQ@*UUJ4io*OPz*g z(@Q0PE4#dIyCrcg>#Ar$mv+2C~4$`%>SVc!=qe$)`)!LiM{H|g48k*;-es{V` zXzOg0ARvNWeh4;0TeTYRU?4{KX043ctQ~N<*1OXnK0Aa^$I7_ePk(K>2(oeSg=;pb z86m*-t}&f6F!;sDyw%7MB?a~~Jc_W2F_L-YXKs@g)ao({7D`=|Ws8mBklO^|*!0o^ z=k~0>`x`bl!I0MYl?HcV1 zzh-dI&-|;2i@*$QSx|wk-F)+1v3)$u5kj*tw$h%Jiw5ILEp>Qt9=}70jQ01qm|kuI z4Uv5t@4-H6Y*)J}rG!(5it^o2XCG;H<4vtfdrCf^@$ywwY?$_p4KnD6d2r(`UCV@@ zo!ff!oyx@(LDD92?src)(HJAcZ}b>k5h3lm8rcnNrZ*yG{n!&&6XV1pfx! z!$x5&1jWq)Bd;Y33M&rDiqr^K0FMzoUKy)2KB znKW+W%ul#K@BW4tW2w{wU~Lm{{k^m3f8Rt^a_n>S5Fb!9L&=YrL8*S_(;F)a!hi!lFLi69E&7kN%Y|0UWeb~$uB=W3}k-r5y`BGa&iisr=VuZKp zYK^r(HSKeXb)YhRh3^r}%l?XF<<@fLdGz`8`SS4bWg9C3@sJ}N#}v49r72v#DjD1F zXQcD-f(|HYWAGzzgoFCkaZp)uMb%<2cDb#Z<5?4R*5Xjv+hwc#M_js@%Djw1JAv)) zZ`0IZvVI-(#=ADci>yKkPAaaeB-n*;!x|>gLfsXQ4wtNy(@CL|_p4h$4QJOhcU3@_=@-tprFIvBv%57Qrrf*_ZEJz6<#(+UV06{yQ?6PFml_UCH*3@4wGc zE>yL&QyfP9sM<`fLc}1tV?@NbhPKP~Ra}c58KQ+><2I6lwa&6US=EZI3dBP|);JP2 zo8wMT{wbXvoCvngOniW71(D@c#K$yeZo2A|CBu{@&h>llMC#L6;kenOFrpS!HlfeW zwb5fT8?el0*3X7CZ+!ywh^*fipoMhOcd+kq1UDZ)_j;fST^vqUEm1XSdd zXX3l#pnH&YxDABJ^Z6%_i!*RjM$3jRunnGS3K&aO;34<#d2{=b4W1|(u+uzdqY;`8 zTw61ElKGlmZvbTvItuK&(_sb8L+f}>MWCZ9iEuq#UY%bYN5Y9bUPQpaG>PVCK_%is zjn=)^cGwKvR{#&^WkGRU2b=FVQQ9qBlw2Ln$AzCk`ELZ5J{=|q{wR{gmar?%=R%!B z`mHg9kOQ3&&L6d|AJA-lDPt^>-Vi4>I-hPp!IV5@4`u zIOHMHAJln6v|&#}QGiJ_-31E`wV|m{!nP?!7ZlFS?ONY^+=Ko$+3j7wpS_D z=tE%k&u-zP@DJOiMt0doEg9LOu*QcKZB^SesWZ+E$6=;)eM$)Qo{^(Sp*g$F$b-nl z6(OVgm!H|@m8OKC&@SN_P-UhI@-+rccZ7oFCXH6&kauIIPj(@(_GFPi`61S8l{WV~ zUVU0LDSwc_cu{~x6qh+6xN1|X8)RoDVVnXtXAYlZUsvz+sNU7MYo#-$=FbL83L@~mhJ1|8~^qxjNCO$~me5J1(K zJW6PiQJ1R)G!nm8p>ts@hbD&_iQE#JbK-}cm?IYZm$eJbXbsVeuHK0dR+$dqN=?Hu zr3z79^lj=ZCx^!BYca1$RKd(LY)7NykT??kUIduGs4%+nu<$SHBd zJyK%MmG7-@D7H0!HYI8N{fd}MNyiGhC{W@l^&F}*BP7|IF;6t zvqu!99J+BtwcW`?@0Pn^-KC_3^m84!ru8n}WvnV$4)8|hs+o%@r>xrHp{puS{T>m{ zIbWVS01JxUEw)GGo0H=T>R5aPpP(&S?3@r;k+n)rGpccBYK5wX!qVevoNTB|Yiuoj zWfoLk?0lHdPufOj!iTP`=)Z1j(x}gaw1+&b`m4U14eMlgkFA<3gDoRogjFSWd!pA| zb6xz%af8C~CtuRE1LIb?LIS;`9CvdJ$IQyTm5i}bzHlKzV~NRz8b(+Xk|Vt77LBMCqG3$sa7 zLfg5Hm5Zdw$uuFPVg5J1y+#wMq{4KHtHoU>){-z3+oih4F>Q{A^yt9kiCg<#2k+vt zgC#z2w20TeG681DNn<%7%e|K9oDW!dt<3J#8Y84pq$hXkcF^G-8g_8foiaPwo_ZtT zO~_|b`Ny;1r|nPW+~L+njfzRb$@J6HIge}y%01T)XH-8HV@qDULD?-|4OYL~V3s9@ zBd9BvyfDMB?>KAQLn>8xeUw%O_}a^n7iI@Iy|m|oY;d{YPm=EFJee^M_nQ>l17Mzz zvE@-CK?Ub(6r4yMMFRGwNxasz8H$X8TUvto@l4KzQ{pkvVEI__rj`h~Y9q>>35QzK3~YG~n5X{_TMv3Uq&(-T=eGHeT1#o7WVO?<@i?Q^_g ztxrm>TepOR5`@1rLI&#eLJ=G%YbZw{tEo-bPolTdZuIQlaP6_mT%?ZG#;`x!VLt&C zu!maU2*842KJ*U=_M;6SyEm`4zDH5sSnPQQ#yzUj)S5${VbSL@yz4&}hA| z^NNA35@Q>(78$O4h4v`j3_-}^HgFKnIM3WJ4M6k9fK2ND8dCdWD(Q&LLQ^Uu0eMcf z1GPEiiB9m8f5vK|MZ5Ilm5R}UtMEk*1%h2LM`*wh_{8RmlkAr_mr2R=4T2{Jzvh${ zmf#NH%evULY8G$-<2+v=?N%$lF6MnWP~!b3$*i(Nhq%PNTS%p5kjg>>#GVKNzXRY; z;oh-$-xO=$Hu{)7aj;u*e$GKpcNpj!_OCwvcHH9RvP?dc2+O9aRa5b0M`9Cq#5cts(=A~!W
    5`IqnW#9 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 H;n@BF@UHen literal 0 HcmV?d00001 diff --git a/src/lib/orderman/order_factory/OrderFactory.cpp b/src/lib/orderman/order_factory/OrderFactory.cpp index fa725f001..370299c5b 100644 --- a/src/lib/orderman/order_factory/OrderFactory.cpp +++ b/src/lib/orderman/order_factory/OrderFactory.cpp @@ -1,5 +1,6 @@ #include "OrderFactory.h" #include "lib/api/services/OrderService.pb.h" +#include "lib/domain_model/Security.pb.h" #include "lib/logging/logging.h" #include "lib/orderman/orderman_utils/ExecutionReport.h" #include "lib/orderman/orders/EMNativeOrder.h" @@ -121,21 +122,22 @@ Order &OrderFactory::recover(api::orderman::OrderRecord const &rec) { } NativeOrderBase *OrderFactory::make_order(const api::Venue exchange) { + LOG(OrderMan, Info, "OrderFactory::make_order exchange: {}", + api::Venue_Name(exchange)); if (exchange == api::Venue::VENUE_ICE || exchange == api::Venue::VENUE_SIMICE) return new ICENativeOrder(); - else - // return new GLBXNativeOrder(); - return new EMNativeOrder(); + else if (exchange == api::VENUE_GLBX || exchange == api::VENUE_SIM) + return new GLBXNativeOrder(); + return new EMNativeOrder(); } NativeOrderBase *OrderFactory::make_native_order( const api::orderman::OrderDefinition &def) { auto secptr = me->sec_db.resolve(SecurityKey(def.security_key())); if (secptr == nullptr) - // return new GLBXNativeOrder(); // GLBX Native can handle unresolved - return new EMNativeOrder(); - // securities + // GLBX Native can handle unresolved securities + return new GLBXNativeOrder(); else return make_order(secptr->exchange()); } diff --git a/src/lib/utils/AuthSessionManager.cpp b/src/lib/utils/AuthSessionManager.cpp index c130b4769..d4e8ee92e 100644 --- a/src/lib/utils/AuthSessionManager.cpp +++ b/src/lib/utils/AuthSessionManager.cpp @@ -1,20 +1,22 @@ #ifndef _WIN32 #include "AuthSessionManager.h" +#include "lib/utils/FileUtils.h" #include "lib/utils/crypto/CryptoInit.h" #include "lib/utils/crypto/KeyCodeHelper.h" #include "lib/utils/crypto/PrivateKey.h" #include "lib/utils/crypto/PublicKey.h" #include "lib/utils/datetime.h" -#include "lib/utils/FileUtils.h" + #include "lib/config/config.h" -#include "lib/config/protos/ports.pb.h" #include "lib/config/protos/keycode.pb.h" +#include "lib/config/protos/ports.pb.h" #include "lib/logging/logging.h" #include "lib/utils/bts_assert.h" #include "lib/utils/helper_macros.h" + #include #include #include @@ -32,6 +34,9 @@ namespace auth { AuthSessionManager::AuthSessionManager() : _map(), _nusers(), _expiration(), _concurrent(false) { + LOG(Gen, Info, + "AuthSessionManager::cons _nusers: {} _expiration: {} _concurrent: {}", + _nusers, _expiration, _concurrent); // const auto &ekc = config::get(); // auto pub = bts::crypto::PublicKey::read(config::get()); @@ -45,7 +50,7 @@ AuthSessionManager::AuthSessionManager() // bts_assert_msg(validate_ip_port(kc), "invalid ip or port in keycode"); } -bool AuthSessionManager::validate_ip_port(const bts::config::KeyCode &/*kc*/) { +bool AuthSessionManager::validate_ip_port(const bts::config::KeyCode & /*kc*/) { // bool portgood = true; // if (kc.has_port() && kc.port() != "") { // const auto &ports = config::get(); @@ -67,9 +72,9 @@ bool AuthSessionManager::validate_ip_port(const bts::config::KeyCode &/*kc*/) { } bool AuthSessionManager::add_or_replace_session( - const api::user::TokenPayload &/*tok*/, - const std::string &/*username*/, - std::string */*msg*/) { + const api::user::TokenPayload & /*tok*/, + const std::string & /*username*/, + std::string * /*msg*/) { // if (tok.wheel()) // return true; // if (datetime::ll_diff_in_us(datetime::ll_now(), _expiration) < 0) { @@ -80,15 +85,20 @@ bool AuthSessionManager::add_or_replace_session( // return false; // } // if (msg) { - // if (datetime::ll_diff_in_seconds(tok.date(), _expiration) < 86400) // 1d - // *msg = "*** YOUR BTS KEYCODE WILL EXPIRE TOMORROW!!, PLEASE CONTACT " + // if (datetime::ll_diff_in_seconds(tok.date(), _expiration) < 86400) // + // 1d + // *msg = "*** YOUR BTS KEYCODE WILL EXPIRE TOMORROW!!, PLEASE CONTACT + // " // "sales@bluetradesys.com ***"; // else if ( - // datetime::ll_diff_in_seconds(tok.date(), _expiration) < 259200) // 3d - // *msg = "Your BTS Keycode EXPIRES IN LESS THAN 3 DAYS, please contact " + // datetime::ll_diff_in_seconds(tok.date(), _expiration) < 259200) // + // 3d + // *msg = "Your BTS Keycode EXPIRES IN LESS THAN 3 DAYS, please contact + // " // "sales@bluetradesys.com"; // else if ( - // datetime::ll_diff_in_seconds(tok.date(), _expiration) < 432000) // 5d + // datetime::ll_diff_in_seconds(tok.date(), _expiration) < 432000) // + // 5d // *msg = "Your BTS Keycode expires in less than one week, please " // "contact sales@bluetradesys.com"; // } @@ -108,19 +118,21 @@ bool AuthSessionManager::add_or_replace_session( // if (msg) // *msg = "KEYCODES: Not Enough Logins available for session"; // LOG(User, Error, - // "KEYCODES: Not Enough Logins available for session {} user:{}", tok.id(), - // username); + // "KEYCODES: Not Enough Logins available for session {} user:{}", + // tok.id(), username); // return false; return true; } -bool AuthSessionManager::check_session(const api::user::TokenPayload &/*tok*/) { +bool AuthSessionManager::check_session( + const api::user::TokenPayload & /*tok*/) { // if (tok.wheel()) // return true; // if (datetime::ll_diff_in_us(datetime::ll_now(), _expiration) > 0) { // auto it = _map.find(tok.id()); // if (it != _map.end()) { - // // return google::protobuf::util::MessageDifferencer::Equivalent(tok, + // // return + // google::protobuf::util::MessageDifferencer::Equivalent(tok, // // it->second.token) //this is probably slow // bool not_expired = // datetime::ll_diff_in_us(tok.date(), _expiration) > 0; diff --git a/src/server/sparkd/cmds/CMECert.cpp b/src/server/sparkd/cmds/CMECert.cpp index 15d3f1a1b..fbfc52681 100644 --- a/src/server/sparkd/cmds/CMECert.cpp +++ b/src/server/sparkd/cmds/CMECert.cpp @@ -40,12 +40,14 @@ struct SessionSaver { "session.txt"} {} void save() { + LOG(OrderMan, Info, "CMECert save path: {}", path); std::ofstream writer(path, std::ios::binary); writer << current.uuid << " " << current.to_cme << " " << current.from_cme; writer.close(); } bool load() { + LOG(OrderMan, Info, "CMECert load path: {}", path); std::ifstream reader(path, std::ios::binary); if (reader) { reader >> current.uuid >> current.to_cme >> current.from_cme;

  • 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�vy*k+BL-7*6ot6B2^Nb84le?n= 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 k|L;w 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±HY>*FQK--# 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�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