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 67ca54095..000000000 Binary files a/src/lib/orderman/ilink3/generated/sbe-all-1.17.0.jar and /dev/null differ diff --git a/src/lib/orderman/ilink3/generated/sbe-all-1.27.0.jar b/src/lib/orderman/ilink3/generated/sbe-all-1.27.0.jar new file mode 100644 index 000000000..c1ed66852 Binary files /dev/null and b/src/lib/orderman/ilink3/generated/sbe-all-1.27.0.jar differ 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;